Spring拦截器实现登陆验证

Spring为我们提供了org.springframework.web.servlet.handler.HandlerInterceptorAdapter这个适配器，
继承此类，可以非常方便的实现自己的拦截器。他有三个方法：

public boolean preHandle(HttpServletRequest request, HttpServletResponse response，Object handler)  
        throws Exception {  
         return true;  
     }   
    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 {  
     }

分别实现预处理、后处理（调用了Service并返回ModelAndView，但未进行页面渲染）、返回处理（已经渲染了页面） 
在preHandle中，可以进行编码、安全控制等处理；  在postHandle中，有机会修改ModelAndView； 
在afterCompletion中，可以根据ex是否为null判断是否发生了异常，进行日志记录。  
如果基于xml配置使用Spring MVC，可以利用SimpleUrlHandlerMapping、
BeanNameUrlHandlerMapping进行Url映射（相当于 struts的path映射）和拦截请求（注入interceptors），
如果基于注解使用Spring MVC，可以使用DefaultAnnotationHandlerMapping注入interceptors。注意无论
基于xml还是基于注 解，HandlerMapping bean都是需要在xml中配置的。

<bean id="timeBasedAccessInterceptor" class="com.spring.handler.TimeBasedAccessInterceptor">   
     <property name="openingTime" value="9" />  
    <property name="closingTime" value="12" />   
     <property name="mappingURL" value=".*/user\.do\?action=reg.*" />  
 </bean>   
 <bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">   
    <property name="interceptors">  
        <list>   
            <ref bean="timeBasedAccessInterceptor"/>  
         </list> 
     </property>  
 </bean>

这里我们定义了一个mappingURL属性，实现利用正则表达式对url进行匹配，从而更细粒度的进行拦截。当然如果不定义mappingURL，则默认拦截所有对Controller的请求。  
UserController：

@Controller   
@RequestMapping("/user.do")   3. public class UserController{ 
    @Autowired   
     private UserService userService;   
     @RequestMapping(params="action=reg")   
    public ModelAndView reg(Users user) throws Exception {  
         userService.addUser(user);   
         return new ModelAndView("profile","user",user);   
     }   
    // other option ...   
 }

 这个Controller相当于Struts的DispatchAction  
你也可以配置多个拦截器，每个拦截器进行不同的分工。

拦截器接口：

package org.springframework.web.servlet;  
public interface HandlerInterceptor {  
    boolean preHandle(  
            HttpServletRequest request, HttpServletResponse response,   
            Object handler)   
            throws Exception;  
  
    void postHandle(  
            HttpServletRequest request, HttpServletResponse response,   
            Object handler, ModelAndView modelAndView)   
            throws Exception;  
  
    void afterCompletion(  
            HttpServletRequest request, HttpServletResponse response,   
            Object handler, Exception ex)  
            throws Exception;  
}

 preHandle：预处理回调方法，实现处理器的预处理（如登录检查），第三个参数为响应的处理器（如我们上一章的Controller实现）；

     返回值：true表示继续流程（如调用下一个拦截器或处理器）；

             false表示流程中断（如登录检查失败），不会继续调用其他的拦截器或处理器，此时我们需要通过response来产生响应；

postHandle：后处理回调方法，实现处理器的后处理（但在渲染视图之前），此时我们可以通过modelAndView（模型和视图对象）对模型数据进行处理或对视图进行处理，modelAndView也可能为null。

afterCompletion：整个请求处理完毕回调方法，即在视图渲染完毕时回调，如性能监控中我们可以在此记录结束时间并输出消耗时间，还可以进行一些资源清理，类似于try-catch-finally中的finally，但仅调用处理器执行链中preHandle返回true的拦截器的afterCompletion。

//拦截器适配器
//doDispatch方法  
//1、处理器拦截器的预处理（正序执行）  
HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();  
if (interceptors != null) {  
    for (int i = 0; i < interceptors.length; i++) {  
    HandlerInterceptor interceptor = interceptors[i];  
        if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) {  
            //1.1、失败时触发afterCompletion的调用  
            triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);  
            return;  
        }  
        interceptorIndex = i;//1.2、记录当前预处理成功的索引  
}  
}  
//2、处理器适配器调用我们的处理器  
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());  
//当我们返回null或没有返回逻辑视图名时的默认视图名翻译（详解4.15.5 RequestToViewNameTranslator）  
if (mv != null && !mv.hasView()) {  
    mv.setViewName(getDefaultViewName(request));  
}  
//3、处理器拦截器的后处理（逆序）  
if (interceptors != null) {  
for (int i = interceptors.length - 1; i >= 0; i--) {  
      HandlerInterceptor interceptor = interceptors[i];  
      interceptor.postHandle(processedRequest, response, mappedHandler.getHandler(), mv);  
}  
}  
//4、视图的渲染  
if (mv != null && !mv.wasCleared()) {  
render(mv, processedRequest, response);  
    if (errorView) {  
        WebUtils.clearErrorRequestAttributes(request);  
}  
//5、触发整个请求处理完毕回调方法afterCompletion  
triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);  
// triggerAfterCompletion方法  
private void triggerAfterCompletion(HandlerExecutionChain mappedHandler, int interceptorIndex,  
            HttpServletRequest request, HttpServletResponse response, Exception ex) throws Exception {  
        // 5、触发整个请求处理完毕回调方法afterCompletion （逆序从1.2中的预处理成功的索引处的拦截器执行）  
        if (mappedHandler != null) {  
            HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();  
            if (interceptors != null) {  
                for (int i = interceptorIndex; i >= 0; i--) {  
                    HandlerInterceptor interceptor = interceptors[i];  
                    try {  
                        interceptor.afterCompletion(request, response, mappedHandler.getHandler(), ex);  
                    }  
                    catch (Throwable ex2) {  
                        logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);  
                    }  
                }  
            }  
        }  
    }  
//性能监控
package cn.javass.chapter5.web.interceptor;  
public class StopWatchHandlerInterceptor extends HandlerInterceptorAdapter {  
    private NamedThreadLocal<Long>  startTimeThreadLocal =   
new NamedThreadLocal<Long>("StopWatch-StartTime");  
    @Override  
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,   
Object handler) throws Exception {  
        long beginTime = System.currentTimeMillis();//1、开始时间  
        startTimeThreadLocal.set(beginTime);//线程绑定变量（该数据只有当前请求的线程可见）  
        return true;//继续流程  
    }  
      
    @Override  
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,   
Object handler, Exception ex) throws Exception {  
        long endTime = System.currentTimeMillis();//2、结束时间  
        long beginTime = startTimeThreadLocal.get();//得到线程绑定的局部变量（开始时间）  
        long consumeTime = endTime - beginTime;//3、消耗的时间  
        if(consumeTime > 500) {//此处认为处理时间超过500毫秒的请求为慢请求  
            //TODO 记录到日志文件  
            System.out.println(  
String.format("%s consume %d millis", request.getRequestURI(), consumeTime));  
        }          
    }  
}  
//登录检测
@Override  
public boolean preHandle(HttpServletRequest request, HttpServletResponse response,   
Object handler) throws Exception {  
    //1、请求到登录页面 放行  
    if(request.getServletPath().startsWith(loginUrl)) {  
        return true;  
    }  
          
    //2、TODO 比如退出、首页等页面无需登录，即此处要放行 允许游客的请求  
          
    //3、如果用户已经登录 放行    
    if(request.getSession().getAttribute("username") != null) {  
        //更好的实现方式的使用cookie  
        return true;  
    }  
          
    //4、非法请求 即这些请求需要登录后才能访问  
    //重定向到登录页面  
    response.sendRedirect(request.getContextPath() + loginUrl);  
    return false;  
}