springmvc的拦截器实现HandlerInterceptor接口后，会有三个抽象方法需要实现，分别为方法前执行preHandle，方法后postHandle，页面渲染后afterCompletion。
1、当俩个拦截器都实现放行操作时，顺序为preHandle 1，preHandle 2，postHandle 2，postHandle 1，afterCompletion 2，afterCompletion 1
2、当第一个拦截器preHandle返回false，也就是对其进行拦截时，第二个拦截器是完全不执行的，第一个拦截器只执行preHandle部分。
3、当第一个拦截器preHandle返回true，第二个拦截器preHandle返回false，顺序为preHandle 1，preHandle 2 ，afterCompletion 1


总结：

preHandle按拦截器定义顺序调用
postHandler按拦截器定义逆序调用
afterCompletion按拦截器定义逆序调用
 
postHandler在拦截器链内所有拦截器返成功调用
afterCompletion只有preHandle返回true才调用



拦截器使用


1、先自定义拦截器类，实现HandlerInterceptor接口，并重写抽象方法进行拦截器的拦截逻辑

public class Interceptor1 implements HandlerInterceptor{
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object arg2) throws Exception {
		// TODO Auto-generated method stub
		System.out.println("方法前 1");
		//判断用户是否登陆  如果没有登陆  重定向到登陆页面   不放行   如果登陆了  就放行了
		String requestURI = request.getRequestURI();
		if(!requestURI.contains("/login")){
			String username = (String) request.getSession().getAttribute("USER_SESSION");
			if(null == username){
				response.sendRedirect(request.getContextPath() + "/login.action");
				return false;
			}
		}
		return true;
	}
	public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3)
			throws Exception {
		// TODO Auto-generated method stub
		System.out.println("方法后 1");	
	}
	public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3)
			throws Exception {
		// TODO Auto-generated method stub
		System.out.println("页面渲染后 1");	
	}
}


2、在springmvc配置文件中进行配置


		<!-- Springmvc的拦截器 -->
		<mvc:interceptors>
			<!-- 多个拦截器 -->
			<mvc:interceptor>
				<mvc:mapping path="/**"/>
				<!-- 自定义的拦截器类 -->
				<bean class="com.iss.springmvc.interceptor.Interceptor1"/>
			</mvc:interceptor>
		</mvc:interceptors>

我们配置多个拦截器，看看输出结果：



开始执行


查看结果



我们可以看出多个拦截器的执行顺序为

preHandle：从第一个往后执行
postHandle：从后往前执行
afterCompletion：从后往前执行

这里的先后为配置拦截器的顺序：
 <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="Interceptors.FirstInterceptor"/><!-- 第一个拦截器 -->
        </mvc:interceptor>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <bean class="Interceptors.SecondInterceptor"/><!-- 第二个拦截器 -->
        </mvc:interceptor>
        <!--<ref bean="firstInterceptor"></ref>-->
    </mvc:interceptors>

为什么会是这种顺序呢，我们一步一步通过源码流程来看：
当我们preHandle（）返回值全部为true时


经过上述分析，我们可以清晰的了解到为什么会有那种顺序的执行方式了

那要是拦截器链的所有preHandle中有的返回false呢？
preHandle（）返回false
还是用我们上面的案例，设置两个preHandle返回值都为false

看运行结果：
First preHandle

下面来看分析：



通过分析和结果证明了我们的推理过程
还是用我们上面的案例，设置第一个为true，第二个为false

看运行结果：
First preHandle
Second preHandle
First afterHandle

我们通过上面的分析过程再来分析：

在进入applyHandle方法后，通过if条件判断，第一个preHandle返回true，执行一次，输出First preHandle，InterceptorIndex计数一次，第二次判断的时候执行了第二个拦截器的preHandle，输出在second preHandle，该拦截器返回false，然后执行triggerAfterCompletion（），根据计数InterceptorIndex执行对应拦截器的afterCompletion方法，输出First AfterHandle

话不多说直接上代码
一、正常流程下的拦截器（全部放行）

1.springMVC中拦截器实现这个接口HandlerInterceptor
第一个拦截器 HandlerInterceptor1

public class HandlerInterceptor1 implements HandlerInterceptor {
	//进入 Handler方法之前执行
	//用于身份认证、身份授权
	//比如身份认证，如果认证通过表示当前用户没有登陆，需要此方法拦截不再向下执行
	@Override
	public boolean preHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler) throws Exception {
		System.out.println("HandlerInterceptor1...preHandle");
		//return false表示拦截，不向下执行
		//return true表示放行
		return true;
	}
	//进入Handler方法之后，返回modelAndView之前执行
	//应用场景从modelAndView出发：将公用的模型数据(比如菜单导航)在这里传到视图，也可以在这里统一指定视图
	@Override
	public void postHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {
		System.out.println("HandlerInterceptor1...postHandle");
	}
	//执行Handler完成执行此方法
	//应用场景：统一异常处理，统一日志处理
	@Override
	public void afterCompletion(HttpServletRequest request,
			HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
		System.out.println("HandlerInterceptor1...afterCompletion");
	}
}
第二个拦截器 HandlerInterceptor2
public class HandlerInterceptor2 implements HandlerInterceptor {
	//进入 Handler方法之前执行
	//用于身份认证、身份授权
	//比如身份认证，如果认证通过表示当前用户没有登陆，需要此方法拦截不再向下执行
	@Override
	public boolean preHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler) throws Exception {
		System.out.println("HandlerInterceptor2...preHandle");
		//return false表示拦截，不向下执行
		//return true表示放行
		return true;
	}
	//进入Handler方法之后，返回modelAndView之前执行
	//应用场景从modelAndView出发：将公用的模型数据(比如菜单导航)在这里传到视图，也可以在这里统一指定视图
	@Override
	public void postHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {
		System.out.println("HandlerInterceptor2...postHandle");
	}
	//执行Handler完成执行此方法
	//应用场景：统一异常处理，统一日志处理
	@Override
	public void afterCompletion(HttpServletRequest request,
			HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
		System.out.println("HandlerInterceptor2...afterCompletion");
	}
}
springMVC.xml中配置两个拦截器


<!--拦截器 -->
<mvc:interceptors>
	<!--多个拦截器,顺序执行 -->
	<mvc:interceptor>
		<!-- /**表示所有url包括子url路径 -->
		<mvc:mapping path="/**"/>
		<bean class="cn.itcast.ssm.interceptor.HandlerInterceptor1"></bean>
	</mvc:interceptor>
	<mvc:interceptor>
		<mvc:mapping path="/**"/>
		<bean class="cn.itcast.ssm.interceptor.HandlerInterceptor2"></bean>
	</mvc:interceptor>
</mvc:interceptors>
查看打印的日志信息



HandlerInterceptor1...preHandle

HandlerInterceptor2...preHandle


HandlerInterceptor2...postHandle

HandlerInterceptor1...postHandle


HandlerInterceptor2...afterCompletion

HandlerInterceptor1...afterCompletion
这是正常的拦截器执行流程


以上执行的拦截器是正常流程的拦截器的顺序
二、非正常情况下的拦截器（第一个拦截器放行，第二个拦截器拦截）
      细心的读者会发现在拦截器中preHandle方法中的返回值我做了注解，  //return false表示拦截，不向下执行//return true表示放行

public class HandlerInterceptor2 implements HandlerInterceptor {
	//进入 Handler方法之前执行
	//用于身份认证、身份授权
	//比如身份认证，如果认证通过表示当前用户没有登陆，需要此方法拦截不再向下执行
	@Override
	public boolean preHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler) throws Exception {
		System.out.println("HandlerInterceptor1...preHandle");
		//return false表示拦截，不向下执行
		//return true表示放行
		return false;
	}

再次启动系统拦截器的执行顺序
日志打印

HandlerInterceptor1...preHandle

HandlerInterceptor2...preHandle

HandlerInterceptor1...afterCompletion

总结：
拦截器1放行，拦截器2 preHandle才会执行。
拦截器2 preHandle不放行，拦截器2 postHandle和afterCompletion不会执行。
只要有一个拦截器不放行，postHandle不会执行。

二、非正常情况下的拦截器（第一个拦截器拦截，第二个拦截器拦截）
public class HandlerInterceptor1 implements HandlerInterceptor {
	//进入 Handler方法之前执行
	//用于身份认证、身份授权
	//比如身份认证，如果认证通过表示当前用户没有登陆，需要此方法拦截不再向下执行
	@Override
	public boolean preHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler) throws Exception {
		System.out.println("HandlerInterceptor1...preHandle");
		//return false表示拦截，不向下执行
		//return true表示放行
		return false;
	}
public class HandlerInterceptor2 implements HandlerInterceptor {
	//进入 Handler方法之前执行
	//用于身份认证、身份授权
	//比如身份认证，如果认证通过表示当前用户没有登陆，需要此方法拦截不再向下执行
	@Override
	public boolean preHandle(HttpServletRequest request,
			HttpServletResponse response, Object handler) throws Exception {
		System.out.println("HandlerInterceptor2...preHandle");
		//return false表示拦截，不向下执行
		//return true表示放行
		return false;
	}

日志打印

HandlerInterceptor1...preHandle
总结


拦截器1 preHandle不放行，postHandle和afterCompletion不会执行。
拦截器1 preHandle不放行，拦截器2不执行。

文章目录
SpringMVC拦截器
1. 过滤器和拦截器的大概执行流程【***】
2. 拦截器的三个方法
3. 多个拦截器的执行顺序
4. SpringMVC拦截器的配置
4.1 自定义拦截器，实现`HandlerInterceptor`接口
4.2 springmvc.xml配置拦截器
5. 案例：用户权限拦截器和日志记录
5.1 案例图解【***】
5.2 用户权限拦截器UserAuthInterceptor
5.3 OrderController订单controller
5.4 CartController购物车controller
5.5 springmvc中配置拦截器

SpringMVC拦截器
  Interceptor拦截器，是SpringMVC提供用来拦截发送给Controller层方法请求的拦截器。类似于filter 主要进行记录日志，判断用户是否登录，过滤权限(没有登录就跳转登录之类的)

  拦截器和我们所学的过滤器是很相似的，只是范围不一样。

过滤器filter：是JavaEE提供的用来拦截所有的请求，进行过滤，它主要用于实现编码过滤，进行统一编码，防止乱码。
拦截器interceptor：主要用来拦截Controller控制器的方法，一般用于拦截Controller层，满足条件才放行，主要用于实现权限分配，不满足条件不能访问一些界面（比如登录才能进入）。

【注意】一般请求都是先通过过滤器filter过滤，才会被拦截器interceptor处理，决定是否放行，两个过程有任何一个不放行，都不能访问到Controller层方法。
1. 过滤器和拦截器的大概执行流程【***】

2. 拦截器的三个方法


boolean preHandle()：在访问controller方法之前执行，返回为true才会去执行Controller方法，返回false，就被拦截了，原路打回（主要做权限控制，有权限才放行）。
void postHandle()：在执行controller方法之后， 执行jsp页面之前执行该方法，可以向作用域中放入数据，影响jsp展示效果，(可以在执行jsp之前做渲染)
void afterCompletion：在jsp页面渲染完成之后执行，（主要用于记录日志，资源释放）

,

【注意小知识点来啦】如果preHadle返回true，但是没有找到对应的Controller，是不会执行postHandle方法哦。


差不多就是这样的模板
public class MyInterceptor implements HandlerInterceptor {

//    在访问controller方法之前执行
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //prehandle:访问controller之前执行，返回true 继续访问controller。
        System.out.println("\n----------AuthInterceptor 【preHandle】--------------");
        return true;//返回false就不再继续执行controller方法
    }

//    如果没有controller就不执行postHandle方法
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
		//posthandle:在执行controller方法之后， 执行jsp之前执行该方法，可以向作用域中放入数据，影响jsp展示效果，(可以执行jsp之前做渲染)
        System.out.println("----------AuthInterceptor 【postHandle】-------------- ");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //afterCompletion:在jsp渲染之后执行，用于记录日志，资源释放
        System.out.println("----------AuthInterceptor 【afterCompletion】--------------");

		//记录日志  向文件里面写日志
        String logdir = request.getServletContext().getRealPath("log");//获取服务器记录日志log文件所存放的目录位置 -- tomcat下的真实路径+log目录
        //路径不存在就创建
        Path logdirPath = Paths.get(logdir);
        if(Files.notExists(logdirPath)){
            Files.createDirectories(logdirPath);
        }
        //目录存在就将数据[字符]写入
        Path logfile = Paths.get(logdir,"userlog.log");//存放日志的路径+文件名
        BufferedWriter writer = new BufferedWriter(new FileWriter(logfile.toFile(),true));//logfile.toFile() paths转换为File类型 true以追加的方式写入
		
		//获取登录用户信息
        Users user = (Users)request.getSession().getAttribute("user");
        String username = user.getUsername();
        //记录user登录时间，存入日志
        String message = username+" 登录时间："+new Date();
        writer.write(message+"\r\n");
        writer.flush();
        writer.close();
    }
}

3. 多个拦截器的执行顺序
如果所有拦截器都通过（都不拦截）执行顺序是这样的：

（都执行的话，preHandle顺序执行，postHandler逆序执行，最后再afterCompletion逆序执行）



如果拦截器1拦截（也就是preHandle1返回false），那么后面的拦截器也不执行，直接原路打回。



如果拦截器3拦截，那么也不执行controller方法，大概是这样的。




4. SpringMVC拦截器的配置
4.1 自定义拦截器，实现HandlerInterceptor接口
//实现一个接口HandlerInterceptor
public class Demo01Interceptor  implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle");
        return true;//放行执行controller
    }

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

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

    }
}

4.2 springmvc.xml配置拦截器
配置多个拦截器
<!-- /** 是拦截所有的请求   path="/interceptor"只拦截interceptor路径-->
     <mvc:interceptors>
         <mvc:interceptor>
         	<!-- /**拦截所有请求，配置全局拦截器 -->
             <mvc:mapping path="/**"/>
             <bean class="com.xgf.springmvc.ajax.interceptor.AuthInterceptor"/>
         </mvc:interceptor>
         <mvc:interceptor>
         	<!-- /interceptor 之拦截interceptor该路径 -->
             <mvc:mapping path="/interceptor"/>
             <bean class="com.xgf.springmvc.ajax.interceptor.AuthInterceptor1"/>
         </mvc:interceptor>
     </mvc:interceptors>

5. 案例：用户权限拦截器和日志记录
有些页面只有用户登录才能访问，未登录不能访问。
5.1 案例图解【***】


浏览器进行访问，想去购物车模块/订单模块需要先进行用户登录，用户权限拦截器进行判断用户登录没有，登录成功，放行，可以访问。未登录，拦截，跳转登录界面。
5.2 用户权限拦截器UserAuthInterceptor
作用：判断访问路径，如果访问的是order订单模块或者cart购物车模块.就需要判断用户是否登录，读取session中的用户信息，未登录强制跳转到登入页面，登录就放行，进入相应页面
public class UserAuthInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("UserAuthInterceptor preHandle------------------------");
        User user = (User) request.getSession().getAttribute("user");
        if(user == null){//未登录才判断，登录了直接放行
            String address = request.getRequestURI();//获取路径
            System.out.println("address = "+address);
            //是购物车或者订单页面，就直接跳转登录界面
            if(address.contains("order")||address.contains("cart")){
	            //强制到登录页面
                response.sendRedirect(request.getContextPath() + "/login.jsp");
                //设置为false，不访问controller
                return false;
            }
        }
        //其它模块或者已经登录，就直接放行
        return true;
    }

    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("UserAuthInterceptor postHandle------------------------");
    }

    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("UserAuthInterceptor afterCompletion------------------------");
        
		//记录日志  向文件里面写日志
        String logdir = request.getServletContext().getRealPath("log");//获取服务器记录日志log文件所存放的目录位置 -- tomcat下的真实路径+log目录
        //路径不存在就创建
        Path logdirPath = Paths.get(logdir);
        if(Files.notExists(logdirPath)){
            Files.createDirectories(logdirPath);
        }
        //目录存在就将数据[字符]写入
        Path logfile = Paths.get(logdir,"userlog.log");//存放日志的路径+文件名
        BufferedWriter writer = new BufferedWriter(new FileWriter(logfile.toFile(),true));//logfile.toFile() paths转换为File类型 true以追加的方式写入
		
		//获取登录用户信息
        Users user = (Users)request.getSession().getAttribute("user");
        String username = user.getUsername();
        //记录user登录时间，存入日志
        String message = username+" 登录时间："+new Date();
        writer.write(message+"\r\n");
        writer.flush();
        writer.close();
    }
}


5.3 OrderController订单controller
订单模块
@Controller
@RequestMapping("/toOrder")
public class OrderController {
    @RequestMapping(path = "/orderInfo.action",method = {RequestMethod.GET,RequestMethod.POST})
    public String query(Integer id){
        System.out.println("订单信息");
        return "order";
    }
}

5.4 CartController购物车controller
购物车模块
@Controller
@RequestMapping("/toCart")
public class OrderController {
    @RequestMapping(path = "/cartInfo.action",method = {RequestMethod.GET,RequestMethod.POST})
    public String query(Integer id){
        System.out.println("购物车信息");
        return "cart";
    }
}

5.5 springmvc中配置拦截器
   <!--配置用户权限拦截器-->
    <mvc:interceptors>
        <!--用于测试的拦截器-->
        <mvc:interceptor>
            <!--拦截路径的配置 /**拦截所有请求 -->
            <mvc:mapping path="/**"/>
            <bean id="interceptor1" class="com.xgf.interceptor.UserAuthInterceptor"/>
        </mvc:interceptor>
	<!-- 可以配置多个拦截器，继续用mvc:interceptor-->
    </mvc:interceptors>


大佬们，画图不容易啊，给个关注给个赞呗，感谢感谢=