精华内容
下载资源
问答
  • java web 拦截器过滤器区别

    千次阅读 2015-07-10 09:41:10
    什么是拦截器(Interceptor )?  拦截器,在AOP(Aspect-Oriented Programming)中用于在某个方法或字段被访问之前,进行拦截然后在之前或之后加入某些操作。拦截是AOP的一种实现策略。  在WEB中,它提供了一种...

    什么是拦截器(Interceptor )?

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

             在WEB中,它提供了一种机制可以使开发者可以定义在一个action执行的前后执行的代码,也可以在一个action执行前阻止其执行。同时也是提供了一种可以提取action中可重用的部分的方式。这是Webwork中给出的解释。

            拦截器链(InterceptorChain,struts中叫做拦截器栈 InterceptorStack),就是将拦截器按一定的顺序联结成一条链。在访问被拦截的方法或字段时,拦截器链中的拦截器就会

    按其之前定义的顺序被调用。

    什么是过滤器(filter)?

            过滤器是一个程序,它先于与之相关的servlet或JSP页面运行在服务器上。过滤器可附加到一个或多个servlet或JSP页面上,并且可以检查进入这些资源的请求信息。在这

    之后,过滤器可以作如下的选择:

           1.以常规的方式调用资源(即,调用servlet或JSP页面)。

           2.利用修改过的请求信息调用资源。

           3.调用资源,但在发送响应到客户机前对其进行修改。

           4.阻止该资源调用,将其转到其他的资源,返回一个特定的状态代码或生成替换输出。

    两者的区别:

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

          2.拦截器不依赖与servlet容器,过滤器依赖与servlet容器。

          3.拦截器只能对action请求起作用,而过滤器则可以对几乎所有的请求起作用,包括一些静态资源的访问。

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

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

    不说了直接上代码:

    拦截器:

    public class UserInterceptor extends AbstractInterceptor {
    
    	private static final long serialVersionUID = 1L;
    	private Logger log=LoggerFactory.getLogger(UserInterceptor.class);
    	@Override
    	public String intercept(ActionInvocation invocation) throws Exception {
    		String result;
    		  String methodName = invocation.getInvocationContext().getName();
    		  log.info(methodName);
    		  Object action = invocation.getAction();
    	        if(action instanceof UserAction)
    	        {
    	        	//如果是UserAction  dosomething
    	        	UserAction useraction = (UserAction)action;
    	        	
    	        }
    	        log.info("调用之前doSomething..........");
    	        result=invocation.invoke();//调用被拦截的方法
    	        log.info("调用之后doSomething..........");
    	        return result;
    	}
    
    }
    
    struts2配置:

    <?xml version="1.0" encoding="utf-8"?>
    <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" "http://struts.apache.org/dtds/struts-2.3.dtd">
    <struts> 
      <package name="default" extends="struts-default" >
      	    <interceptors>
    		 <interceptor name="userInterceptor" class="lishuai.interceptor.UserInterceptor"></interceptor>
    		 <interceptor-stack name="interceplist">
    		   <interceptor-ref name="defaultStack"></interceptor-ref>
    		   <interceptor-ref name="userInterceptor"></interceptor-ref>
    		 </interceptor-stack>
    		</interceptors>
    		
            <action name="user_*"  class="lishuai.action.UserAction" method="{1}"> 
               <interceptor-ref name="interceplist"></interceptor-ref>
    		</action> 
      </package>
    
    </struts>
    注:action配的是个拦截器栈,注意defaultStack是struts2的默认拦截器如果不配置则会覆盖掉struts2的默认拦截器,后果就是模型驱动(ModelDriven<T>)或者属性注入等,会

    注入失败。

    过滤器:

    public class CharacterEncodingFilter implements Filter {
    	/*
    	 * 编码方式
    	 */
    	private String characterEncoding;
    	/*
    	 * 是否启用
    	 */
    	private boolean enabled;
    
    	@Override
    	public void destroy() {
    		// TODO Auto-generated method stub
    
    	}
    
    	@Override
    	public void doFilter(ServletRequest request, ServletResponse response,
    			FilterChain chain) throws IOException, ServletException {
    		
    		if (enabled || characterEncoding != null) {
    		           request.setCharacterEncoding(characterEncoding);
    			            response.setCharacterEncoding(characterEncoding);
    			        }
    		chain.doFilter(request, response);
    	}
    
    	@Override
    	public void init(FilterConfig config) throws ServletException {
    		 characterEncoding = config.getInitParameter("characterEncoding");
             enabled = "true".equalsIgnoreCase(config.getInitParameter("enabled").trim());
    	}
    
    }
    web.xml配置:

    	<filter>
    		<filter-name>CharacterEncodingFilter</filter-name>
    		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    		<init-param>
    			<param-name>encoding</param-name>
    			<param-value>utf-8</param-value>
    		</init-param>
    	</filter>
    	<filter-mapping>
    		<filter-name>CharacterEncodingFilter</filter-name>
    		<url-pattern>/*</url-pattern>
    	</filter-mapping>
    注: 自己定义的过滤器要放到strtus2的过滤器之前的, 如果放在struts2过滤器之后,你自己的过滤器对action的过滤作用就废了,不会有效!除非你是访问jsp/html,切记。











     

       

    展开全文
  • java-web servlet 拦截器 过滤器使用 java-web servlet 拦截器 过滤器使用
  • 拦截器(Interceptor)和过滤器(Filter)的执行顺序区别

    一、引言

    本来想记录一下关于用户登陆和登陆之后的权限管理、菜单管理的问题,想到解决这个问题用到Interceptor,但想到了Interceptor,就想到了Filter,于是就想说一下它们的执行顺序和区别。关于Interceptor解决权限和菜单管理的问题,在放在下一篇写吧,就酱紫。

    二、区别

    1、过滤器(Filter)

    首先说一下Filter的使用地方,我们在配置web.xml时,总会配置下面一段设置字符编码,不然会导致乱码问题:

    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <servlet-name>/*</servlet-name>
    </filter-mapping>
    

    配置这个地方的目的,是让所有的请求都需要进行字符编码的设置,下面来介绍一下Filter。

    (1)过滤器(Filter):它依赖于servlet容器。它可以对几乎所有请求进行过滤,但是缺点是一个过滤器实例只能在容器初始化时调用一次。使用过滤器的目的,是用来做一些过滤操作,获取我们想要获取的数据,比如:在Javaweb中,对传入的request、response提前过滤掉一些信息,或者提前设置一些参数,然后再传入servlet或者Controller进行业务逻辑操作。通常用的场景是:在过滤器中修改字符编码(CharacterEncodingFilter)、在过滤器中修改HttpServletRequest的一些参数(XSSFilter(自定义过滤器)),如:过滤低俗文字、危险字符等。

    2、拦截器(Interceptor)

    拦截器的配置一般在SpringMVC的配置文件中,使用Interceptors标签,具体配置如下:

    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**" />
            <bean class="com.scorpios.atcrowdfunding.web.LoginInterceptor"></bean>
        </mvc:interceptor>
        <mvc:interceptor>
            <mvc:mapping path="/**" />
            <bean class="com.scorpios.atcrowdfunding.web.AuthInterceptor"></bean>
        </mvc:interceptor>
    </mvc:interceptors>
    

    (2)拦截器(Interceptor):它依赖于web框架,在SpringMVC中就是依赖于SpringMVC框架。在实现上,基于Java的反射机制,属于面向切面编程(AOP)的一种运用,就是在service或者一个方法前,调用一个方法,或者在方法后,调用一个方法,比如动态代理就是拦截器的简单实现,在调用方法前打印出字符串(或者做其它业务逻辑的操作),也可以在调用方法后打印出字符串,甚至在抛出异常的时候做业务逻辑的操作。由于拦截器是基于web框架的调用,因此可以使用Spring的依赖注入(DI)进行一些业务操作,同时一个拦截器实例在一个controller生命周期之内可以多次调用。拦截器可以对静态资源的请求进行拦截处理。

    三、代码


    下面在一个项目中我们使用既有多个过滤器,又有多个拦截器,并观察它们的执行顺序:
    (1)第一个过滤器:

    public class TestFilter1 implements Filter {  
      
    		@Override
      	    protected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {  
            //在DispatcherServlet之前执行  
    		System.out.println("############TestFilter1 doFilterInternal executed############");  
            filterChain.doFilter(request, response);  
            //在视图页面返回给客户端之前执行,但是执行顺序在Interceptor之后  
            System.out.println("############TestFilter1 doFilter after############");  
        }  
    }  
    

    (2)第二个过滤器:

    public class TestFilter2 implements Filter {  
     
    	@Override
        protected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {  
    	    //在DispatcherServlet之前执行  
            System.out.println("############TestFilter2 doFilterInternal executed############");  
            filterChain.doFilter(request, response);  
            //在视图页面返回给客户端之前执行,但是执行顺序在Interceptor之后 
            System.out.println("############TestFilter2 doFilter after############");  
        }  
    }  
    

    (3)在web.xml中注册这两个过滤器:

    <!-- 自定义过滤器:testFilter1 -->   
    <filter>  
        <filter-name>testFilter1</filter-name>  
        <filter-class>com.scorpios.filter.TestFilter1</filter-class>  
    </filter>  
    <filter-mapping>  
        <filter-name>testFilter1</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>  
    
    <!-- 自定义过滤器:testFilter2 -->   
    <filter>  
        <filter-name>testFilter2</filter-name>  
        <filter-class>com.scorpios.filter.TestFilter2</filter-class>  
    </filter>  
    <filter-mapping>  
        <filter-name>testFilter2</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>  
    

    再定义两个拦截器:
    (4)第一个拦截器:

    public class BaseInterceptor implements HandlerInterceptor{  
         
        /** 
         * 在DispatcherServlet之前执行 
         * */  
        public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {  
            System.out.println("************BaseInterceptor preHandle executed**********");  
            return true;  
        }  
     
        /** 
         * 在controller执行之后的DispatcherServlet之后执行 
         * */  
        public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3) throws Exception {  
            System.out.println("************BaseInterceptor postHandle executed**********");  
        }  
         
        /** 
         * 在页面渲染完成返回给客户端之前执行 
         * */  
        public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3)  
                throws Exception {  
            System.out.println("************BaseInterceptor afterCompletion executed**********");  
        }  
    }  
    

    (5)第二个拦截器:

    public class TestInterceptor implements HandlerInterceptor {  
     
        public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {  
            System.out.println("************TestInterceptor preHandle executed**********");  
            return true;  
        }  
     
        public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3) throws Exception {  
            System.out.println("************TestInterceptor postHandle executed**********");  
        }  
     
        public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3) throws Exception {  
            System.out.println("************TestInterceptor afterCompletion executed**********");  
        }  
    }  
    

    (6)、在SpringMVC的配置文件中,加上拦截器的配置:

    <!-- 拦截器 -->  
    <mvc:interceptors>  
        <!-- 对所有请求都拦截,公共拦截器可以有多个 -->  
        <bean name="baseInterceptor" class="com.scorpios.interceptor.BaseInterceptor" />  
    
        <mvc:interceptor> 
            <!-- 对/test.jsp进行拦截 -->       
            <mvc:mapping path="/test.jsp"/>  
            <!-- 特定请求的拦截器只能有一个 -->  
            <bean class="com.scorpios.interceptor.TestInterceptor" />  
        </mvc:interceptor>  
    </mvc:interceptors>  
    

    (7)、定义一个Controller控制器:

    package com.scorpios.controller;  
    import org.springframework.stereotype.Controller;  
    import org.springframework.web.bind.annotation.RequestMapping;  
    import org.springframework.web.servlet.ModelAndView;  
      
    @Controller  
    public class TestController {  
        @RequestMapping("/test")  
        public ModelAndView handleRequest(){  
            System.out.println("---------TestController executed--------");  
            return new ModelAndView("test");  
        }  
    }  
    

    (8)、测试结果:
    启动测试项目,地址如下:http://www.localhost:8080/demo,可以看到控制台中输出如下:
    这里写图片描述
    这就说明了过滤器的运行是依赖于servlet容器,跟springmvc等框架并没有关系。并且,多个过滤器的执行顺序跟xml文件中定义的先后关系有关。

    接着清空控制台,并访问:http://www.localhost:8080/test,再次看控制台的输出:
    这里写图片描述
    从这个控制台打印输出,就可以很清晰地看到有多个拦截器和过滤器存在时的整个执行顺序了。当然,对于多个拦截器它们之间的执行顺序跟在SpringMVC的配置文件中定义的先后顺序有关。

    四、总结


    对于上述过滤器和拦截器的测试,可以得到如下结论:

    • Filter需要在web.xml中配置,依赖于Servlet

    • Interceptor需要在SpringMVC中配置,依赖于框架

    • Filter的执行顺序在Interceptor之前,具体的流程见下图
      在这里插入图片描述

    • 两者的本质区别:拦截器(Interceptor)是基于Java的反射机制,而过滤器(Filter)是基于函数回调。从灵活性上说拦截器功能更强大些,Filter能做的事情,都能做,而且可以在请求前,请求后执行,比较灵活。Filter主要是针对URL地址做一个编码的事情、过滤掉没用的参数、安全校验(比较泛的,比如登录不登录之类),太细的话,还是建议用interceptor。不过还是根据不同情况选择合适的。

    展开全文
  • SSM项目中使用拦截器和过滤器

    多人点赞 热门讨论 2021-04-16 22:26:48
    SSM项目中使用拦截器和过滤器一、拦截器概述二、拦截器配置步骤1、创建一个拦截器(实现HandlerInterceptor接口)2、配置拦截器3、测试下拦截器:三、过滤器概述四、过滤器配置步骤1、创建一个过滤器(实现Filter接口)2...

    一、拦截器概述

    Spring MVC 也可以使用拦截器对请求进行拦截处理,用户可以自定义拦截器来实现特定 的功能,自定义的拦截器必须实现 HandlerInterceptor 接口

    • preHandle():这个方法在业务处理器处理请求之前被调用,在该方法中对用户请求 request 进行处理。如果程序员决定该拦截器对请求进行拦截处理后还要调用其他 的拦截器,或者是业务处理器去进行处理,则返回 true;如果程序员决定不需要 再调用其他的组件去处理请求,则返回 false。
    • postHandle():这个方法在业务处理器处理完请求后,但是 DispatcherServlet向客户端返回响应前被调用,在该方法中对用户请求 request 进行处理。
    • afterCompletion():这个方法在 DispatcherServlet 完全处理完请求后被调用,可以 在该方法中进行一些资源清理的操作。

    二、拦截器配置步骤

    1、创建一个拦截器(实现HandlerInterceptor接口)

    package com.ssm.Interceptor;
    
    import org.springframework.web.servlet.HandlerInterceptor;
    import org.springframework.web.servlet.ModelAndView;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    
    //拦截器
    public class LoginInterceptor implements HandlerInterceptor {
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            //获取请求的URL
            String requestURI=request.getRequestURI();
            HttpSession session=request.getSession();
            Object userInfo=request.getSession().getAttribute("USERINFO");
            System.out.println("链接:"+requestURI+"进入拦截器");
            if(userInfo==null){ //表示未登录就想进入系统
                //直接重定向到登录界面
                String serverPath=request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+request.getContextPath()+"/index.jsp";
                response.sendRedirect(serverPath);
                return false;
            }else{
                //登陆成功,不拦截
                return true;
            }
    
        }
    
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
            System.out.println("跳转后拦截");
        }
    
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
            System.out.println("渲染后拦截");
        }
    }
    
    

    这个拦截器我只是写个Demo,所以只进行了是否登录的验证,真正的项目中你也可以在这里进行一些权限的判断等等。

    2、配置拦截器

    <!--拦截器配置-->
    	<mvc:interceptors>
    		<!--后台访问拦截器-->
    		<mvc:interceptor>
    			<!--拦截所有资源-->
    			<mvc:mapping path="/**"/>
    			<!--登陆不拦截-->
    			<mvc:exclude-mapping path="/user/login"/>
    			<!--邮箱激活不拦截-->
    			<mvc:exclude-mapping path="/user/activeEmail"/>
    			<!--静态资源的目录不拦截-->
    			<mvc:exclude-mapping path="/commons/**"/>
    			<!--用户通过邮箱中重置密码的链接不拦截-->
    			<mvc:exclude-mapping path="/email/resetPassword"/>
    			<!--激活邮箱的验证不拦截-->
    			<mvc:exclude-mapping path="/user/validateCode"/>
    			<!--实现拦截功能的类-->
    			<bean class="com.ssm.Interceptor.LoginInterceptor"></bean>
    		</mvc:interceptor>
    	</mvc:interceptors>
    

    由于配置了<mvc:mapping path="/**"/>会拦截所有资源,我们必须用<mvc:exclude-mapping path="/这里写你想放行的请求">标签放行静态资源和一些不用拦截的请求(登录等等)。<bean class="com.ssm.Interceptor.LoginInterceptor"></bean>是第一步创建的拦截器。

    3、测试下拦截器:

    在地址栏输入个非法的请求试试:
    在这里插入图片描述
    在这里插入图片描述
    通过地址栏可以看到,页面已经被重定向到了登陆界面,拦截成功。
    但是拦截器并不能拦截jsp页面的访问,这个时候两种选择:
    1、将所有jsp页面都放在WEB-INF目录下
    2、用Servlet过滤器(虽然感觉技术有点老了)

    三、过滤器概述

    Servlet过滤器主要用于对客户端(浏览器)的请求进行过滤处理,然后将过滤后的请求转交给下一资源。

    四、过滤器配置步骤

    1、创建一个过滤器(实现Filter接口)

    package com.ssm.Filter;
    
    import javax.servlet.*;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    import java.io.IOException;
    
    //自定义过滤器
    public class LoginFilter implements Filter {
        //初始化方法
        @Override
        public void init(FilterConfig filterConfig) throws ServletException {
         //初始化处理
            System.out.println("过滤器初始化");
        }
    
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            //过滤处理
            //servletRequest 是个接口,HttpServletRequest 是实现,但是有些方法是HttpServletRequest独有的,如:getSession
            //HttpServletRequest接口是继承servletRequest接口,增加了和http相关的方法
            HttpServletRequest request= (HttpServletRequest) servletRequest;
            HttpServletResponse response= (HttpServletResponse) servletResponse;
    //        String requestURI=request.getRequestURI();
    //        System.out.println("链接:"+requestURI+"进入过滤器");
            HttpSession session=request.getSession();
            if(session.getAttribute("USERINFO")==null){
                //非法请求,直接跳转到登陆界面
                String serverPath=request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+request.getContextPath()+"/index.jsp";
                response.sendRedirect(serverPath);
            }else{
                //正常登录,放行
                filterChain.doFilter(request,response);
            }
        }
    
        @Override
        public void destroy() {
         //释放资源
            System.out.println("过滤器销毁");
        }
    }
    
    

    2、配置web.xml

    <!--使用过滤器实现登陆控制-->
      <!--filter标签用于声明过滤器对象-->
      <filter>
        <!--过滤器名称-->
        <filter-name>LoginFilter</filter-name>
        <!--过滤器完整类名-->
        <filter-class>com.ssm.Filter.LoginFilter</filter-class>
      </filter>
      <!--filter-mapping用于创建过滤器的映射,指定Web应用中,哪些URL应用哪一个过滤器进行处理-->
      <filter-mapping>
        <filter-name>LoginFilter</filter-name>
        <!--url-pattern用于指定过滤器应用的URL-->
        <!--过滤的页面(自定义),这里对登录界面就不要过滤了-->
        <url-pattern>/views/*</url-pattern>
      </filter-mapping>
    

    各个标签的解释都写在注释里面了,至于需要过滤的资源,你可以根据自己的需求再添加<url-pattern>,我主要是想把views目录下面的jsp全部过滤。

    3、测试过滤器

    不登陆直接访问后台jsp页面:
    在这里插入图片描述
    访问之后:
    在这里插入图片描述

    可以看到,过滤器直接将请求重定向到了登陆界面,过滤器过滤成功。

    五、总结

    现在已经有了很多权限管理的框架了,Shiro、Spring Security等等,以后尽量还是用新技术。

    展开全文
  • 拦截器和过滤器的区别,从实现原理到应用场景各处区别
  • SpringBoot拦截器和过滤器的一起使用

    千次阅读 2018-12-24 23:24:29
    Springboot 使用拦截器拦截请求@Controllert和页面访问 ...拦截器和过滤器的区别最大的就是拦截器的范围要大,一般来说过滤器过滤的时页面,不能过滤请求,拦截器不但能拦截请求还能拦截页面。代码如下: packag...

    Springboot 使用拦截器拦截请求@Controllert和页面访问

    你好! 本人在做一个项目时,要用到拦截器和过滤器 ,目的是为了让用户先登陆再操作,防止用户直接访问页面或者请求。自己就上网找了找,发现有好多方法,自己也总结了一下,结合使用。拦截器和过滤器的区别最大的就是拦截器的范围要大,一般来说过滤器过滤的时页面,不能过滤请求,拦截器不但能拦截请求还能拦截页面。代码如下:
    package com.ysd.util;

    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession;
    
    import org.springframework.stereotype.Component;
    import org.springframework.web.servlet.HandlerInterceptor;
    import org.springframework.web.servlet.ModelAndView;
    
    @Component
    public class MyInterceptor implements HandlerInterceptor {
    	@Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object o) throws Exception {
    		HttpSession session = request.getSession();
    		String uri = request.getRequestURI();
    		System.out.println("filter url:"+uri);
    		System.out.println("----------开始进行拦截-----------");
            if (session.getAttribute("user") != null) {
            	System.out.println("-----------拦截通过----------");
                return true;
            }else {
            	System.out.println("-----------拦截不通过----------");
                // 跳转登录
                String url = request.getContextPath() + "/login2.html";
                response.sendRedirect(url);
                return false;
            }
    	}
    	@Override public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o,
    			ModelAndView modelAndView) throws Exception {
    		System.out.println("myinterc posthandler");
    		}
    	@Override public void afterCompletion(HttpServletRequest httpServletRequest, 
    			HttpServletResponse httpServletResponse, Object o,
    			Exception e) throws Exception {
    		System.out.println("myinterc aftercompletion");
    		}
    }
    

    这就定义了一个拦截器 ,只需implements HandlerInterceptor就行 ,重写方法,其中需要修改的是preHandle()方法。然后可以使用@Component把类配置一个bean,
    之后在创建一个类AddInterceptor(名字自己起) 实现implements WebMvcConfigurer(Springboot 2.0版本之后的使用,之前的话使用WebMvcConfigurerAdapter,这个需要自己重写方法)在类上加注解@Configuration,代码如下
    package com.ysd.util;

    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;
    
    @Configuration
    public class AddInterceptor implements  WebMvcConfigurer{
       @Autowired
       private MyInterceptor myInterceptor;
       
        public void addInterceptors(InterceptorRegistry registry){
            registry.addInterceptor(myInterceptor)
            .addPathPatterns("/**")
            .excludePathPatterns("/login2.html","/js/**","/img/**","/login/denglu");
        }
    }
    

    具体的过滤可以自己定义,之间使用逗号(“,”)分隔,addPathPatterns()是要过滤的页面,**代表所有,excludePathPatterns()时除了什么不拦截 ,登陆页面肯定不拦截,要不一直重定向,当然还有css样式,图片img。本人萌新,有什么不对的欢迎指教!!!

    展开全文
  • springboot下使用拦截器和过滤器

    万次阅读 多人点赞 2018-07-01 13:29:06
    Spring MVC的拦截器(Interceptor)Filter不同,但是也可以实现对请求进行预处理,后处理。先介绍它的使用,只需要两步: 1.1 实现拦截器 实现拦截器可以自定义实现HandlerInterceptor接口,也可以通过继承...
  • Java中增加自定义的拦截器和过滤器

    千次阅读 2019-01-15 18:43:02
    拦截器和过滤器是Java开发中经常用到的,Java中增加自定义的拦截器和过滤器,方式分别如下, 一,Java的springboot增加自定义拦截器 1,首先各个拦截器类需要事先定义,并实现 org.springframework.web.servlet....
  • 拦截器过滤器的区别

    万次阅读 多人点赞 2019-06-20 23:11:09
    文章目录一、二者理解过滤器(Filter)拦截器(Interceptor)二、拦截器过滤器的区别区别:三、拦截器过滤器的触发时机拦截器过滤器触发时机不一样四、使用场景五、图解 一、二者理解 过滤器(Filter) 过滤器...
  • 过滤器和拦截器的区别:  ①拦截器是基于Java的反射机制的,而过滤器是基于函数回调。  ②拦截器不依赖与servlet容器,过滤器依赖与servlet容器。  ③拦截器只能对action请求起作用,而过滤器则可以对...
  • 实现用户登录过程的验证,用拦截器和过滤器可以拦截用户没有登录的情况下,不能进行访问系统页面 以下是自定义拦截器工程目录实现的过程: 1:新建一个 interceptor 拦截器包,创建一个 LoginInterceptor 拦截器类...
  • 拦截器和过滤器详解

    千次阅读 2019-09-03 23:42:36
    过滤器和拦截器的区别: 拦截器是基于java的反射机制的,而过滤器是基于函数回调。 拦截器不依赖与servlet容器,过滤器依赖与servlet容器。 拦截器只能对action请求起作用,而过滤器则可以对几乎所有的请求起...
  • 1、拦截器是基于java的反射机制的,而过滤器是基于函数回调  2、过滤器依赖与servlet容器,而拦截器不依赖与servlet容器  3、拦截器只能对action请求起作用,而过滤器则可以对几乎所有的请求起作用  4、拦截器...
  • Java Web 过滤器和拦截器

    千次阅读 2017-06-03 23:15:17
    1.什么是过滤器1....在学习SSH框架时我们经常会在web.xml中配置struts的过滤器 <!--配置Struts2过滤器--> <filter-name>struts2 <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsP
  • 转:... 拦截器过滤器的区别总结: 过滤器web.xml中配置: (1)因为一开始在过滤器中映射的url-pattern填写路径是*.action。所有的action要经过它的过滤。url-pattern>*.actionurl
  • 关于拦截器过滤器使用场景、区别整理
  • SpringBoot实现拦截器和过滤器

    千次阅读 2018-07-12 10:53:35
    一、使用Interceptor拦截器 1.首先新建一个拦截器实现HandlerInterceptor接口 以一个简单的token验证为例,验证通过,将用户信息放入作用域,返回true 不通过返回false @Service public class ...
  • 为了体系化控制用户登录,做粗粒度的认证登录,可以采用应用层的拦截器过滤器来实现。经验证测试发现只有strutsspring在自身层面上支持,不能同时支持各种请求拦截,为此考虑粗粒度处理,因此考虑使用filter机制...
  • springmvc 拦截器和过滤器有什么区别

    千次阅读 2018-08-07 13:01:18
    过滤器是基于函数回调的,需要依赖servlet容器,在请求进入容器后,还未进入Servlet之前进行预处理,并且请求结束返回给前端进行后期处理,只能在容器初始化时调用一次,可以自定义过滤器实现并在web.xml中注册 ...
  • Spring中拦截器和过滤器的使用

    万次阅读 多人点赞 2018-11-27 20:13:37
    作用域差异:Filter是Servlet规范中规定的,只能用于WEB中,拦截器既可以用于WEB,也可以用于Application、Swing中(即过滤器是依赖于Servlet容器的,它类似的还有Servlet中的监听器同样依赖该容器,而拦截器则不...
  • struts 拦截器和过滤器的区别和原理

    千次阅读 2017-12-10 16:17:53
    拦截器的工作原理:当接收到一个httprequest ,a) 当外部的httpservletrequest到来时 b) 初始到了servlet容器 传递给一个标准的过滤器链 c) FilterDispatecher会去查找相应的ActionMapper,如果找到了相应的...
  • 1、首先要明确什么是拦截器、什么是过滤器 1.1 什么是拦截器拦截器,在AOP(Aspect-Oriented Programming)中用于在某个方法或字段被访问之前,进行拦截然后在之前或之后加入某些操作。拦截是AOP的一种实现...
  • 首先要明确什么是拦截器、什么是过滤器1.1 什么是拦截器拦截器,在AOP(Aspect-Oriented Programming)中用于在某个方法或字段被访问之前,进行拦截然后在之前或之后加入某些操作。拦截是AOP的一种实现策略。 在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 77,837
精华内容 31,134
关键字:

web拦截器和过滤器