精华内容
下载资源
问答
  • java中拦截器和过滤器
    2022-05-08 16:01:52

    在基于SSM框架的项目实战中,不管是写一个什么项目,前后台的分离是必不可少的。自JavaWeb中的过滤器,到Spring MVC中新增了拦截器,目的也是为了分离前后台。

    对于二者的理解:

    过滤器(FIlter):过滤器实际上是对一些web资源进行拦截 ,做一些处理后再交给下一个Servlet或者过滤器处理,它通常是用来拦截request进行处理的,也可以对返回的response进行拦截处理。

    拦截器(Intercepter):拦截器主要是用于拦截用户请求并做相应的处理,通常应用在权限验证、记录请求信息的日志、判断用户是否登录等等。

    二者的使用:(实现拦截后台)

    过滤器(FIlter):过滤器是实现了javax.servlet下的Filter接口,重写Filter中的三个方法:初始化init,过滤doFIlter,销毁destroy,其中doFilter()方法是去实现过滤相关内容的方法。

    import javax.servlet.*;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    import java.io.IOException;
    
    public class ManagerFilter implements Filter {
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
            System.out.println("初始化过滤器");
        }
    
        @Override
        public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
            HttpServletRequest req= (HttpServletRequest) request;
            HttpServletResponse resp= (HttpServletResponse) response;
            HttpSession session = req.getSession();
            Integer status = (Integer) session.getAttribute("status");
            System.out.println(status);
            if (session.getAttribute("status") == null || (Integer) session.getAttribute("status") != 3) {
                req.setAttribute("meg", "你没有权限访问后台!");
                System.out.println("过滤器拦截--------");
                resp.sendRedirect("/MusicWebSite/index.html");
            } else {
                System.out.println("过滤器放行------------------------");
                chain.doFilter(req,resp);
            }
        }
    
        @Override
        public void destroy() {
            System.out.println("过滤器销毁");
        }
    }

    当然,过滤器的配置配置也是必不可少的,而过滤器主要是过滤页面的,就需要在web.xml中进行相关配置。 

        <filter>
            <filter-name>ManagerFilter</filter-name>
            <filter-class>project.filter.ManagerFilter</filter-class>
        </filter>
        <filter-mapping>
            <filter-name>ManagerFilter</filter-name>
            <url-pattern>/html/manager.html</url-pattern>
        </filter-mapping>

    拦截器(Intercepter):而定义一个拦截器,一般可以通过实现HandlerInterceptor接口或者继承HandlerInterceptor接口的实现类定义,还有一种已经过时的方法是通过WebRequestInterceptor接口或者继承WebRequestInterceptor接口的实现类定义,拦截器中的三个方法:

    preHandle:控制器方法执行之前执行preHandle(),其boolean类型的返回值表示是否拦截或放行,返回true为放行,即调用控制器方法;返回false表示拦截,即不调用控制器方法

    postHandle:控制器方法执行之后执行postHandle()

    afterComplation:处理完视图和模型数据,渲染视图完毕之后执行afterComplation()

    
    
    import org.springframework.stereotype.Component;
    import org.springframework.web.servlet.HandlerInterceptor;
    import org.springframework.web.servlet.ModelAndView;
    
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    
    
    public class ManagerInterceptor extends HttpServlet implements HandlerInterceptor {
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            HttpSession session = request.getSession();
            Integer status = (Integer) session.getAttribute("status");
            if (session.getAttribute("status") == null || (Integer) session.getAttribute("status") != 3) {
                request.setAttribute("meg", "你没有权限访问后台!");
                System.out.println("拦截器拦截--------");
                response.sendRedirect("/index.html");
                return false;
            } else {
                System.out.println("拦截器放行------------------------");
                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 {
         
        }
    }
    
    
    
         <mvc:interceptors>
            <mvc:interceptor>
                <mvc:mapping path="/manager/**"/>
                <bean class="project.interceptor.ManagerInterceptor"></bean>
            </mvc:interceptor>
        </mvc:interceptors>

    其中mvc:mapping是你需要拦截的controller的url,如果你不需要排除一些特定的url,就需要使用mvc:exclude-mapping属性。

    更多相关内容
  • java中拦截器和过滤器详解

    千次阅读 2022-01-06 17:14:14
    1 过滤器和拦截器的异同 1.1 一张图表明两者之间的差异: tomcat,filter,servet,interceptor以及controller等各种容器的关系图 1.2 两者的区别: 拦截器是基于java的反射机制的,而过滤器是基于函数回调。 ...

    1 过滤器和拦截器的异同

    1.1 一张图表明两者之间的差异:

    tomcat,filter,servet,interceptor以及controller等各种容器的关系图

    https://pic3.zhimg.com/v2-da6aae17a961060915487d27e10d1d5a_r.jpg

    1.2 两者的区别:

    • 拦截器是基于java的反射机制的,而过滤器是基于函数回调。

    • 拦截器不依赖与servlet容是依赖于spring容器,过滤器依赖与servlet容器。

    • 拦截器只能对action请求起作用,而过滤器则可以对几乎所有的请求起作用,可以限制用户对图片,文件以及其他资源的访问。

    • 拦截器可以访问action请求上下文、值栈里的对象,而过滤器不能访问。

    • 在action的生命周期中,拦截器可以多次被调用(因为拦截器是基于反射机制实现的,即通过加载java字节码而实现的函数的调用,所以每一次运行拦截器的时候都需要找到拦截器相关的字节码并且执行),而过滤器只需在容器初始化时被调用一次(意思是只需要调用一次,filter过滤器程序就会一直在内存中执行下去,每当碰到一次请求,服务器无需再次调用都会进行拦截,除非被主动摧毁。(1)启动服务器时加载过滤器的实例,并调用init()方法来初始化实例;(2)、每一次请求时都只调用方法doFilter()进行处理;(3)、停止服务器时调用destroy()方法,销毁实例。)。

    • 拦截器可以获取IOC容器中的各个bean,而过滤器就不行,这点很重要,在拦截器里注入一个service,可以调用业务逻辑。

    1.3 两者的相同之处:

    本文主要对基于Spring boot对过滤器和拦截器的配置进行的讲解。无论是过滤器还是拦截器都属于AOP(面向切面编程)思想的具体实现。

    2 过滤器

    2.1 用法

    当Web容器接受到一个对资源的请求时:

    1. 它将判断是否有过滤器与这个资源相关联。
    2. 如果有,那么容器将把请求交给过滤器进行处理。在过滤器中,你可以改变请求的内容,或者重新设置请求的报头信息,然后再将请求发送给目标资源
    3. 当目标资源对请求作出响应时候,容器同样会将响应先转发给相应的过滤器。

    2.2 作用

    在过滤器中你可以对响应的内容进行转换,然后再将响应发送到客户端。常见的过滤器用途

    主要包括:

    • 对用户请求进行统一认证
    • 对用户的访问请求进行记录和审核、
    • 对用户发送的文本数据进行过滤或替换,比如替换掉脏话、
    • 转换图象格式、
    • 对响应内容进行压缩以减少传输量、
    • 对请求或响应进行加解密处理、
    • 触发资源访问事件、
    • 对XML的输出应用XSLT等。

    2.3 实现过滤器 方法一:不使用@WebFilter下,既需要编写过滤器类,又要编写配置类

    2.3.1 先编写过滤器类

    过滤器类就是指 当拦截到某一个请求后,在该请求发往servlet容器前,执行什么操作,需要进行什么处理

    public class LogCostFilter implements Filter{
        @Override
        public void init(FilterConfig filterConfig)throws ServletException{
        }
        @Override
        public void doFilter(ServletRequest servletRequest,ServletResponse servletResponse,FilterChain filterChain)throws IOException,ServletException{
            long start =System.currentTimeMillis();
            filterChain.doFilter(servletRequest,servletResponse);
            System.out.println("Execute cost="+(System.currentTimeMillis()-start));
        }
        @Override
        public void destroy(){
        }
    }
    

    这段代码的逻辑比较简单,就是在方法执行前先记录时间戳,然后通过过滤器链完成请求的执行,在返回结果之间计算执行的时间。这里需要主要,这个类必须继承Filter类,这个是Servlet的规范,这个跟以前的Web项目没区别。

    2.3.2 再在其配置类中配置过滤器需要拦截的请求类型的正则表达式以及决定使用哪一个过滤器类

    但是,有了过滤器类以后,以前的web项目可以在web.xml中进行配置,但是spring- boot项目并没有web.xml这个文件,那怎么配置?在Spring boot中,我们需要FilterRegistrationBean来完成配置。其实现过程如下:

    
    @Configuration
    public class FilterConfig{
        @Bean
        public FilterRegistrationBean registFilter(){
            FilterRegistrationBean registration =new FilterRegistrationBean();
            registration.setFilter(newLogCostFilter());
            registration.addUrlPatterns("/*");
            registration.setName("LogCostFilter");
            registration.setOrder(1);
            return registration;
        }
    }
    

    这样配置就完成了,需要配置的选项主要包括实例化Filter类,然后指定url的匹配模式,设置过滤器名称和执行顺序,这个过程和在web.xml中配置其实没什么区别,只是形式不同而已。现在我们可以启动服务器访问任意URL:

    https://pic4.zhimg.com/80/v2-5bdb90fc22e1c4f8ae175e7d80721187_1440w.jpg

    2.4 过滤器实现代码 方法二:仅仅使用@WebFilter和过滤器类,不要编写配置类

    大家可以看到上面的配置已经生效了。除了通过 FilterRegistrationBean 来配置以外,还有一种更直接的办法,

    2.4.1 直接通过注解@WebFilter就可以完成了:

    @WebFilter(urlPatterns ="/*", filterName ="logFilter2")
    public class LogCostFilter2 implements Filter{
        @Override
        publicvoid init(FilterConfig filterConfig)throwsServletException{
        }
        @Override
        public void doFilter(ServletRequest servletRequest,ServletResponse servletResponse,FilterChain filterChain)throwsIOException,ServletException{
            long start =System.currentTimeMillis();
            filterChain.doFilter(servletRequest, servletResponse);
            System.out.println("LogFilter2 Execute cost="+(System.currentTimeMillis()- start));
        }
        @Override
        public void destroy(){
        }
    }
    

    2.4.2

    这里直接用@WebFilter就可以进行配置,同样,可以设置url匹配模式,过滤器名称等。这里需要注意一点的是@WebFilter这个注解是Servlet3.0的规范,并不是Spring boot提供的。除了这个注解以外,我们还需在配置类中加另外一个注解:@ServletComponetScan,指定扫描的包。

    @SpringBootApplication
    @MapperScan("com.pandy.blog.dao")
    @ServletComponentScan("com.pandy.blog.filters")
    public class springbootApplication{
        public static void main(String[] args) throws Exception{
            SpringApplication.run(Application.class, args);
        }
    }
    

    现在,我们再来访问一下任意URL:

    https://pic1.zhimg.com/80/v2-7c9f6498a097504593fa6bb708961c80_1440w.jpg

    2.4.3 多个拦截器存在时候的执行顺序问题

    可以看到,我们配置的两个过滤器都生效了。细心的读者会发现,第二个Filter我们并没有指定执行的顺序,但是却在第一个Filter之前执行。这里需要解释一下,@WebFilter这个注解并没有指定执行顺序的属性,其执行顺序依赖于Filter的名称,是根据Filter类名(注意不是配置的filter的名字)的字母顺序倒序排列,并且@WebFilter指定的过滤器优先级都高于FilterRegistrationBean配置的过滤器。有兴趣的朋友可以自己实验一下。

    3 拦截器

    3.1 拦截器定义

    3.1.1 讲一讲拦截器实现的机制。

    在AOP(Aspect-Oriented Programming)中用于在某个方法或字段被访问之前,进行拦截,然后在之前或之后加上某些操作。拦截是AOP的一种实现策略。

    3.1.2 拦截器作用有什么作用呢?

    AOP面向切面有什么作用,那么拦截器就有什么作用。

    • 日志记录:记录请求信息的日志,以便进行信息监控、信息统计、计算PV…
    • 权限检查:认证或者授权等检查性能
    • 监控:通过拦截器在进入处理器之前记录开始时间,处理完成后记录结束时间,得到请求处理时间。
    • 通用行为:读取cookie得到用户信息并将用户对象放入请求头中,从而方便后续流程使用。

    3.1.3 拦截器实现拦截器集成接口HandlerInterceptor,实现拦截,接口方法有下面三种:

    • preHandler(HttpServletRequest request, HttpServletResponse response, Object handler) 方法将在请求处理之前进行调用。SpringMVC中的Interceptor同Filter一样都是链式调用。每个Interceptor的调用会依据它的声明顺序依次执行,而且最先执行的都是Interceptor中的preHandle方法,所以可以在这个方法中进行一些前置初始化操作或者是对当前请求的一个预处理,也可以在这个方法中进行一些判断来决定请求是否要继续进行下去。该方法的返回值是布尔值Boolean 类型的,当它返回为false时,表示请求结束,后续的Interceptor和Controller都不会再执行;当返回值为true时就会继续调用下一个Interceptor 的preHandle 方法,如果已经是最后一个Interceptor 的时候就会是调用当前请求的Controller 方法。

    • postHandler(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) 在当前请求进行处理之后,也就是Controller 方法调用之后执行,但是它会在DispatcherServlet 进行视图返回渲染之前被调用,所以我们可以在这个方法中对Controller 处理之后的ModelAndView 对象进行操作。

    • afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handle, Exception ex) 该方法也是需要当前对应的Interceptor的preHandle方法的返回值为true时才会执行。顾名思义,该方法将在整个请求结束之后,也就是在DispatcherServlet 渲染了对应的视图之后执行。这个方法的主要作用是用于进行资源清理工作的。总结一点就是:preHandle是请求执行前执行postHandle是请求结束执行afterCompletion是视图渲染完成后执行

    3.2 拦截器实现

    3.2.1

    上面我们已经介绍了过滤器的配置方法,接下来我们再来看看如何配置一个拦截器。我们使用拦截器来实现上面同样的功能,记录请求的执行时间。首先我们实现拦截器类:

    public class LogCostInterceptor implements HandlerInterceptor{
        long start =System.currentTimeMillis();
        @Override
        publicboolean preHandle(HttpServletRequest httpServletRequest,HttpServletResponse httpServletResponse,Object o) throws Exception{
            start =System.currentTimeMillis();
            return true;
        }
        @Override
        public void postHandle(HttpServletRequest httpServletRequest,HttpServletResponse httpServletResponse,Object o,ModelAndView modelAndView) throws Exception{
            System.out.println("Interceptor cost="+(System.currentTimeMillis()-start));
        }
        @Override
        publicvoid afterCompletion(HttpServletRequest httpServletRequest,HttpServletResponse httpServletResponse,Object o,Exception e)throwsException{
        }
    }
    

    3.3.2

    这里我们需要实现HandlerInterceptor这个接口,这个接口包括三个方法,preHandle是请求执行前执行的,postHandler是请求结束执行的,但只有preHandle方法返回true的时候才会执行,afterCompletion是视图渲染完成后才执行,同样需要preHandle返回true,该方法通常用于清理资源等工作。除了实现上面的接口外,我们还需对其进行配置:

    @Configuration
    public class InterceptorConfig extends WebMvcConfigurerAdapter{
        @Override
        public void addInterceptors(InterceptorRegistry registry){
            registry.addInterceptor(newLogCostInterceptor()).addPathPatterns("/**");
            super.addInterceptors(registry);
        }
    }
    

    这里我们继承了WebMVCConfigurerAdapter,看过前面的文章的朋友应该已经见过这个类了,在进行静态资源目录配置的时候我们用到过这个类。这里我们重写了addInterceptors这个方法,进行拦截器的配置,主要配置项就两个,一个是指定拦截器,第二个是指定拦截的URL。现在我们再启动系统访问任意一个URL:

    https://pic1.zhimg.com/80/v2-1ea7f81701d182f0c02c0b9bcdeb3aec_1440w.jpg

    可以看到,我们通过拦截器实现了同样的功能。不过这里还要说明一点的是,其实这个实现是有问题的,因为preHandle和postHandle是两个方法,所以我们这里不得不设置一个共享变量start来存储开始值,但是这样就会存在线程安全问题。当然,我们可以通过其他方法来解决,比如通过ThreadLocal就可以很好的解决这个问题,有兴趣的同学可以自己实现。不过通过这一点我们其实可以看到,虽然拦截器在很多场景下优于过滤器,但是在这种场景下,过滤器比拦截器实现起来更简单。

    展开全文
  • 主要介绍了Java的拦截器、过滤器、监听器用法,详细分析了Java拦截器过滤器、监听器的功能、使用方法及相关注意事项,需要的朋友可以参考下
  • Java中拦截器和过滤器有什么区别

    千次阅读 2021-06-23 23:13:46
    3、过滤器基于函数回调方式实现,拦截器基于Java反射机制实现 (四)总结 实际开发拦截器的应用场景会比过滤器要更多,下面是拦截器和过滤器的主要应用场景 拦截器的应用场景:权限控制,日志打印,参数校验 ...

    本文收录于JavaStarter ,里面有我完整的Java系列文章,学习或面试都可以看看

    (一)什么是过滤器

    过滤器Filter基于Servlet实现,过滤器的主要应用场景是对字符编码、跨域等问题进行过滤。Servlet的工作原理是拦截配置好的客户端请求,然后对Request和Response进行处理。Filter过滤器随着web应用的启动而启动,只初始化一次。

    Filter的使用比较简单,继承Filter 接口,实现对应的init、doFilter以及destroy方法即可。

    1、init:在容器启动时调用初始化方法,只会初始化一次

    2、doFilter:每次请求都会调用doFilter方法,通过FilterChain 调用后续的方法

    3、destroy:当容器销毁时,执行destory方法,只会被调用一次。

    下面是详细的代码编写方式:

    public class MyFilter implements Filter {
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
            System.out.println("初始化拦截器");
        }
    
        @Override
        public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
            //做一些处理
            chain.doFilter(request,response);
        }
    
        @Override
        public void destroy() {
            System.out.println("销毁拦截器");
        }
    }
    

    (二)什么是拦截器

    拦截器是SpringMVC中实现的一种基于Java反射(动态代理)机制的方法增强工具,拦截器的实现是继承HandlerInterceptor 接口,并实现接口的preHandle、postHandle和afterCompletion方法。

    1、preHandle:请求方法前置拦截,该方法会在Controller处理之前进行调用,Spring中可以有多个Interceptor,这些拦截器会按照设定的Order顺序调用,当有一个拦截器在preHandle中返回false的时候,请求就会终止。

    2、postHandle:preHandle返回结果为true时,在Controller方法执行之后,视图渲染之前被调用

    3、afterCompletion:在preHandle返回ture,并且整个请求结束之后,执行该方法。

    具体的代码实现如下,首先编写一个拦截器:

    @Component
    public class UserInterceptor implements HandlerInterceptor {
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            System.out.println("preHandle");
            String userName=request.getParameter("userName");
            String password = request.getParameter("password");
            if (userName==null||password==null){
                response.setStatus(500);
                response.setContentType("text/html; charset=UTF-8");
                response.getWriter().print("参数缺失");
                return false;
            }
            //进行用户校验
            if (userName.equals("admin")&&password.equals("admin")){
                return true;
            }else {
                response.setStatus(500);
                response.setContentType("text/html; charset=UTF-8");
                response.getWriter().print("用户名或密码错误");
                return false;
            }
        }
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
            System.out.println("postHandle");
        }
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
            System.out.println("afterCompletion");
        }
    }
    

    编写完拦截器之后,通过一个配置类设置拦截器,并且可以通过addPathPatternsexcludePathPatterns执行哪些请求需要被拦截,哪些不需要被拦截。

    @Configuration
    public class MvcConfig implements WebMvcConfigurer {
        @Autowired
        private UserInterceptor userInterceptor;
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            registry.addInterceptor(userInterceptor)
                    .addPathPatterns("/**")
                    .excludePathPatterns("/error");
        }
    }
    

    (三)拦截器与过滤器的区别

    相同点

    1、拦截器与过滤器都是体现了AOP的思想,对方法实现增强,都可以拦截请求方法。

    2、拦截器和过滤器都可以通过Order注解设定执行顺序

    不同点

    1、过滤器属于Servlet级别,拦截器属于Spring级别
    Filter是在javax.servlet包中定义的,要依赖于网络容器,因此只能在web项目中使用。

    Interceptor是SpringMVC中实现的,归根揭底拦截器是一个Spring组件,由Spring容器进行管理。

    2、过滤器和拦截器的执行顺序不同

    下面通过一张图展示Filter和Interceprtor的执行顺序


    首先当一个请求进入Servlet之前,过滤器的doFilter方法进行过滤,

    进入Servlet容器之后,执行Controller方法之前,拦截器的preHandle方法进行拦截,

    执行Controller方法之后,视图渲染之前,拦截器的postHandle方法进行拦截,

    请求结束之后,执行拦截器的postHandle方法。

    3、过滤器基于函数回调方式实现,拦截器基于Java反射机制实现

    (四)总结

    实际开发中,拦截器的应用场景会比过滤器要更多,下面是拦截器和过滤器的主要应用场景

    拦截器的应用场景:权限控制,日志打印,参数校验

    过滤器的应用场景:跨域问题解决,编码转换

    我翻了一下历史项目的代码,拦截器在用户权限校验场景下使用会比较多,由于一般是前后端分离项目,过滤器的使用场景就会少很多。

    拦截器和过滤器算是比较常用的了,但是还是得注意两者的差距,我是鱼仔,我们下期再见!

    展开全文
  • Java拦截器过滤器

    千次阅读 2022-04-22 23:42:23
    Java拦截器过滤器

    拦截器与过滤器

    流程图

    在这里插入图片描述

    拦截器vs过滤器

    拦截器是SpringMVC的技术

    过滤器的Servlet的技术

    先过过滤器,过滤器过完才到DispatcherServlet;

    拦截器归属于SpringMVC,只可能拦SpringMVC的东西;

    拦截器说白了就是为了增强,可以在请求前进行增强,也可以在请求后进行增强,但是不一定同时在前后都增强。

    区别

    在这里插入图片描述

    SpringMVC技术架构图

    在这里插入图片描述

    项目Demo

    项目地址在这里插入图片描述

    依赖

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

    Interceptor拦截器

    package com.test.filtertest.inter;
    
    import org.springframework.stereotype.Component;
    import org.springframework.web.servlet.HandlerInterceptor;
    import org.springframework.web.servlet.ModelAndView;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    /**
     * 拦截器
     *
     * @author: zhangzengxiu
     * @createDate: 2022/4/22
     */
    @Component
    public class TestInter1 implements HandlerInterceptor {
    
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            System.out.println("TestInter1 preHandle...");
            return true;
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
            System.out.println("TestInter1 postHandle...");
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
            System.out.println("TestInter1 afterCompletion...");
        }
    }
    

    Interceptor拦截器要注册

    package com.test.filtertest.config;
    
    import com.test.filtertest.inter.TestInter1;
    import com.test.filtertest.inter.TestInter2;
    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;
    
    /**
     * @author zhangzengxiu
     * @date 2022/4/22
     */
    @Configuration
    public class WebConfig implements WebMvcConfigurer {
    
        @Autowired
        private TestInter1 testInter1;
    
        @Autowired
        private TestInter2 testInter2;
    
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            //默认/** 拦截所有请求
            registry.addInterceptor(testInter1).addPathPatterns("/**");
            registry.addInterceptor(testInter2);
        }
    }
    

    拦截顺序

    多拦截器拦截顺序取决于registry的注册顺序

    Filter过滤器

    1、多Filter不指定过滤顺序

    package com.test.filtertest.filter;
    
    import org.springframework.core.annotation.Order;
    
    import javax.servlet.*;
    import javax.servlet.annotation.WebFilter;
    import java.io.IOException;
    
    /**
     * @author zhangzengxiu
     * @date 2022/4/22
     */
    @WebFilter(filterName = "TestFilter1", urlPatterns = "/*")
    //@Order(2) //filter这样定义拦截顺序无效,还是会按照类名去拦截
    public class TestFilter1 implements Filter {
    
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
    
        }
    
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            System.out.println("TestFilter1 filter before ...");
            filterChain.doFilter(servletRequest, servletResponse);
            System.out.println("TestFilter1 filter after ...");
        }
    
        @Override
        public void destroy() {
    
        }
    }
    

    加了@WebFilter注解的过滤器要生效,需要在启动类上加一个注解

    @ServletComponentScan
    在这里插入图片描述

    2、多Filter指定过滤顺序

    如果要设置过滤顺序的话,在Filter上添加@Order 不会生效,还是会默认根据Filter过滤器的类名去进行过滤。
    如果想要指定拦截顺序,需要添加一个配置类,通过设置Order的值去设置过滤顺序,Order数值越小优先级越高

    package com.test.config;
    
    import com.test.filter.TestFilter1;
    import com.test.filter.TestFilter2;
    import org.springframework.boot.web.servlet.FilterRegistrationBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import javax.servlet.Filter;
    
    /**
     * filter过滤器配置
     *
     * @author: zhangzengxiu
     * @createDate: 2022/4/24
     */
    @Configuration
    public class FilterConfig {
    
        @Bean
        public FilterRegistrationBean testFilter1() {
            FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
            Filter testFilter1 = new TestFilter1();
            filterRegistrationBean.setFilter(testFilter1);
            filterRegistrationBean.addUrlPatterns("/*");
            filterRegistrationBean.setName("testFilter1");
            filterRegistrationBean.setOrder(2);//指定过滤顺序,数值越小优先级越高
            return filterRegistrationBean;
        }
    
        @Bean
        public FilterRegistrationBean testFilter2() {
            FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
            Filter testFilter2 = new TestFilter2();
            filterRegistrationBean.setFilter(testFilter2);
            filterRegistrationBean.setName("testFilter2");
            filterRegistrationBean.addUrlPatterns("/*");
            filterRegistrationBean.setOrder(1);//指定过滤顺序,数值越小优先级越高
            return filterRegistrationBean;
        }
    }
    
    

    1、同时原本Filter过滤器上的@WebFilter(filterName = “TestFilter1”, urlPatterns = “/*”)
    这个注解最好去掉,否则bean重复会报错,要么bean名称不要重复,换个名称。但是不去掉的话@ServletComponentScan也要被保留,最好统一格式,只使用config配置。

    2、启动类上的@ServletComponentScan 注解也不需要了,可以去掉了,因为不用扫描@WebFilter注解了。但是如果@WebFilter还保留了,那么就不能去掉了。不然加了@WebFilter的过滤器就不会生效了,因为没扫到。
    在这里插入图片描述

    展开全文
  • Java过滤器和拦截器的区别

    千次阅读 多人点赞 2022-05-31 13:20:08
    过滤器和拦截器的区别?
  • 拦截器和过滤器的区别

    千次阅读 2021-03-04 00:21:24
    过滤器和拦截器的区别:①拦截器是基于java的反射机制的,而过滤器是基于函数回调。②拦截器不依赖与servlet容器,过滤器依赖与servlet容器。③拦截器只能对action请求起作用,而过滤器则可以对几乎所有的请求起作用...
  • java-web servlet 拦截器 过滤器使用 java-web servlet 拦截器 过滤器使用
  • filter(过滤器) 有如下几个种类(功能):需要注意的是,一个filter过滤器可以加在多个servlet控制器上,当然多个filter过滤器也是可以加在一个servlet控制器上的。由此也是可以看出来,我们使用filter往往是对...
  • 1.过滤器:所谓过滤器顾名思义是用来过滤的,在java web,你传入的request,response提前过滤掉一些信息,或者提前设置一些参数,然后再传入servlet或者struts的action进行业务逻辑,比如过滤掉非法url(不是login....
  • 主要介绍了通过实例解析java过滤器和拦截器的区别,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 该压缩包实现了利用过滤器或者拦截器对登录信息进行验证跳转登陆页的功能,利用的是SpringBootthymeleaf,使用前请先看使用说明
  • Java过滤器拦截器的区别

    千次阅读 2021-11-09 18:26:59
    Java过滤器拦截器的区别1. 过滤器拦截器概述1.1 过滤器 Filter1.2 拦截器 interceptor2. 过滤器拦截器区别3. 过滤器拦截器实现3.1 过滤器(Filter)3.2 拦截器 (Interceptor)3.3 拦截器WebMvc配置3.4 切片...
  • 总结:java中过滤器和拦截器的区别?

    万次阅读 多人点赞 2018-12-13 18:33:44
    【扩展】 过滤器:Filter 概念:对目标资源的请求响应进行过滤截取。在请求到达servlet之前,进行逻辑判断,判断是否放行到servlet;也可以在一个响应response到达客户端之前进行过滤,判断是否允许返回客户端。 ...
  • 过滤器中修改HttpServletRequest的一些参数,包括:过滤低俗文字、危险字符等 过滤器的顺序每一次都将chain对象传入,达到最后接口回调的效果: 一、实现原理不同 过滤器的实现基于回调函数拦截器基于Java的反射...
  • Java中的AOP、拦截器过滤器

    千次阅读 2021-12-22 21:37:12
    AOP(Aspect Oriented Programming)面向切面编程: 用我目前开发的项目说一下我对AOP的理解 项目的代码层次是:应用层(API)->...比如在API的Controller是接收客户端的http请求的,但是我想在http到达Controll
  • 过滤器,顾名思义就是起到过滤筛选作用的一种事物,只不过相较于现实生活过滤器,这里的过滤器过滤的对象是客户端访问的web资源,也可以理解为一种预处理手段,对资源进行拦截后,将其中我们认为的杂质(用户...
  • java 干货,对接口参数进行的特殊字符,如insert select * % 等进行判断,进行过滤.
  • 主要介绍了struts2过滤器和拦截器的区别,简单分析了struts2框架中过滤器和拦截器的概念与相关使用区别,需要的朋友可以参考下
  • 本篇文章主要介绍了java中SpringMVC 拦截器的使用及其实例,需要的朋友可以参考
  • 拦截器是基于java的反射机制的,而过滤器是基于函数回调。 ②拦截器不依赖与servlet容器,过滤器依赖与servlet容器。 ③拦截器只能对action请求起作用,而过滤器则可以对几乎所有的请求起作用
  • Java(Spring拦截器过滤器、AOP)

    千次阅读 2022-04-08 21:58:49
    过滤器可以拦截到方法的请求响应(ServletRequest request, SetvletResponse response),并对请求响应做出的过滤操作,比如设置字符编码、鉴权操作。 过滤器方法的入参有request,response,FilterChain,其中...
  • Java中增加自定义的拦截器和过滤器

    千次阅读 2019-01-15 18:43:02
    拦截器和过滤器Java开发经常用到的,Java中增加自定义的拦截器和过滤器,方式分别如下, 一,Java的springboot增加自定义拦截器 1,首先各个拦截器类需要事先定义,并实现 org.springframework.web.servlet....
  • 对项目的所有参数去除前后空格...可以基于此过滤器实现过滤跨站脚本攻击,参数的增加,修改!敏感词汇过滤。实现原理为重写HttpServletRequestWrapper,获取参数的方法。include Forwarded 内部转发不在过滤之内。
  • 我的需求就是处理前台传来的请求,在过滤器里面给表达式的值赋值为系统的值。然后传到具体方法过滤器是这么写的: if(StringUtils.isNotEmpty(userId)&&userId.equals(":userId")){ //获取用户id ...
  • 拦截器是基于java的反射机制的,而过滤器是基于函数回调。  ②拦截器不依赖与servlet容器,过滤器依赖与servlet容器。  ③拦截器只能对action请求起作用,而过滤器则可以对几乎所有的请求起作用。  ④拦截器...
  • 今天学习认识了一下,过滤器和SpringMVC的拦截器的区别,学到了不少的东西,以前一直以为拦截器就是过滤器实现的,现在想想还真是一种错误啊,而且看的比较粗浅,没有一个全局而又细致的认识,由于已至深夜,时间...
  • 本案例 使用maven 搭建spring boot 基本案例 其中实现了 用户登录功能,实现Filter 拦截器两种方式 来过滤session登录,后续会使用token方式,请大家关注

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 94,898
精华内容 37,959
关键字:

java中拦截器和过滤器