過濾器、監聽器、攔截器的區別
過濾器
Servlet中的過濾器Filter是實現了javax.servlet.Filter介面的伺服器端程序，主要的用途是過濾字元編碼、做一些業務邏輯判斷等。其工作原理是，只要你在web.xml文件配置好要攔截的客戶端請求，它都會幫你攔截到請求，此時你就可以對請求或響應(Request、Response)統一設置編碼，簡化操作；同時還可以進行邏輯判斷，如用戶是否已經登錄、有沒有許可權訪問該頁面等等工作，它是隨你的web應用啟動而啟動的，只初始化一次，以後就可以攔截相關的請求，只有當你的web應用停止或重新部署的時候才能銷毀。
在javax.servlet.Filter介面中定義了3個方法：
void init(FilterConfig filterConfig) 用於完成過濾器的初始化
void destroy() 用於過濾器銷毀前，完成某些資源的回收
void doFilter(ServletRequest request, ServletResponse response,FilterChain chain) 實現過濾功能，該方法對每個請求增加額外的處理
package com.cn.util;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class FilterUtil implements Filter{
@SuppressWarnings("unused")
private FilterConfig filterConfig;
@Override
public void init(FilterConfig filterConfig) throws ServletException {
this.filterConfig = filterConfig;
System.out.println("過濾器Filter初始化");
}
@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
if (!(request instanceof HttpServletRequest) || !(response instanceof HttpServletResponse)) {
throw new ServletException("FilterUtil just supports HTTP requests");
}
HttpServletRequest httpRequest = (HttpServletRequest) request;
HttpServletResponse httpResponse = (HttpServletResponse) response;
httpRequest.setCharacterEncoding(this.filterConfig.getInitParameter("encoding"));
httpResponse.setCharacterEncoding(this.filterConfig.getInitParameter("encoding"));
chain.doFilter(httpRequest, httpResponse);
}
@Override
public void destroy() {
System.out.println("過濾器Filter銷毀");
}
}
web.xml配置：
<filter>
<filter-name>encodingFilter</filter-name>
<!-- <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> -->
<filter-class>com.cn.util.FilterUtil</filter-class>
<async-supported>true</async-supported>
<init-param>
<param-name>encoding</param-name>
<param-value>UTF-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
監聽器
Servlet的監聽器Listener，它是實現了javax.servlet.ServletContextListener介面的伺服器端程序，它也是隨web應用的啟動而啟動，只初始化一次，隨web應用的停止而銷毀。主要作用是：做一些初始化的內容添加工作、設置一些基本的內容、比如一些參數或者是一些固定的對象等等。
在javax.servlet.ServletContextListener介面中定義了2種方法：
void contextInitialized(ServletContextEvent sce) 監聽器的初始化
void contextDestroyed(ServletContextEvent sce) 監聽器銷毀
package com.cn.util;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
public class ServletContextListenerUtil implements ServletContextListener{
//監聽器的初始化
@Override
public void contextInitialized(ServletContextEvent sce) {
System.out.println("監聽器ServletContextListenerUtil初始化");
}
//監聽器銷毀
@Override
public void contextDestroyed(ServletContextEvent sce) {
System.out.println("監聽器ServletContextListenerUtil銷毀");
}
}
項目啟動時，先啟動監聽器，再啟動過濾器。
攔截器
攔截器是在面向切面編程中應用的，就是在你的service或者一個方法前調用一個方法，或者在方法後調用一個方法比如動態代理就是攔截器的簡單實現，在你調用方法前列印出字元串（或者做其它業務邏輯的操作），也可以在你調用方法後列印出字元串，甚至在你拋出異常的時候做業務邏輯的操作。攔截器不是在web.xml配置的，比如struts在struts.xml配置，在springMVC在spring與springMVC整合的配置文件中配置。
在springmvc中，定義攔截器要實現HandlerInterceptor介面，並實現該介面中提供的三個方法
package com.cn.util;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
public class InterceptorUtil implements HandlerInterceptor{
//進入Handler方法之前執行
//可以用於身份認證、身份授權。如果認證沒有通過表示用戶沒有登陸，需要此方法攔截不再往下執行，否則就放行
@Override
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response, Object handler) throws Exception {
// TODO Auto-generated method stub
System.out.println("InterceptorUtil...........preHandle");
String user= (String) request.getSession().getAttribute("user");
if(user != null){
return true;
}
request.getRequestDispatcher("/WEB-INF/jsp/index.jsp").forward(request, response);
//true表示放行，false表示不放行
return false;
}
@Override
public void postHandle(HttpServletRequest request,
HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception {
// TODO Auto-generated method stub
System.out.println("InterceptorUtil...........postHandle");
}
@Override
public void afterCompletion(HttpServletRequest request,
HttpServletResponse response, Object handler, Exception ex)
throws Exception {
// TODO Auto-generated method stub
System.out.println("InterceptorUtil...........afterCompletion");
}
}
preHandle方法：進入Handler方法之前執行。可以用於身份認證、身份授權。比如如果認證沒有通過表示用戶沒有登陸，需要此方法攔截不再往下執行（return false），否則就放行（return true）。
postHandle方法：進入Handler方法之後，返回ModelAndView之前執行。可以看到該方法中有個modelAndView的形參。應用場景：從modelAndView出發：將公用的模型數據（比如菜單導航之類的）在這裡傳到視圖，也可以在這裡同一指定視圖。
afterCompletion方法：執行Handler完成之後執行。應用場景：統一異常處理，統一日誌處理等。
在springmvc中，攔截器是針對具體的HandlerMapping進行配置的，也就是說如果在某個HandlerMapping中配置攔截，經過該 HandlerMapping映射成功的handler最終使用該攔截器。
spring-mvc.xml配置文件中：
<!-- 攔截器配置 -->
<mvc:interceptors>
<!--多個攔截器,順序執行 -->
<!-- 登陸認證攔截器 -->
<mvc:interceptor>
<!-- /** 表示攔截所有url包括子url路徑，/*只攔截根下的url -->
<mvc:mapping path="/**"/>
<bean class="com.cn.util.InterceptorUtil"></bean>
</mvc:interceptor>
<!-- 其他攔截器 -->
</mvc:interceptors>
在網上查詢的過濾器和攔截器的區別，基本都是以下一模一樣的5行話。
1、攔截器是基於Java的反射機制的，而過濾器是基於函數回調2、過濾器依賴與servlet容器，而攔截器不依賴與servlet容器3、攔截器只能對action請求起作用，而過濾器則可以對幾乎所有的請求起作用4、攔截器可以訪問action上下文、值棧里的對象，而過濾器不能5、在action的生命周期中，攔截器可以多次被調用，而過濾器只能在容器初始化時被調用一次執行順序：過濾前 - 攔截前 - Action處理 - 攔截後 -過濾後。個人認為過濾是一個橫向的過程，首先把客戶端提交的內容進行過濾(例如未登錄用戶不能訪問內部頁面的處理)；過濾通過後，攔截器將檢查用戶提交數據的驗證，做一些前期的數據處理，接著把處理後的數據發給對應的Action；Action處理完成返回後，攔截器還可以做其他過程，再向上返回到過濾器的後續操作。
過濾器（Filter）：當你有一堆東西的時候，你只希望選擇符合你要求的某一些東西。定義這些要求的工具，就是過濾器。
攔截器（Interceptor）：在一個流程正在進行的時候，你希望干預它的進展，甚至終止它進行，這是攔截器做的事情。監聽器（Listener）：當一個事件發生的時候，你希望獲得這個事件發生的詳細信息，而並不想干預這個事件本身的進程，這就要用到監聽器。
context-param：就是一些需要初始化的配置，放入context-param中，從而被監聽器（這裡特指org.springframework.web.context.ContextLoaderListener）監聽，然後載入；
監聽器(listener)：就是對項目起到監聽的作用，它能感知到包括request(請求域)，session(會話域)和applicaiton(應用程序)的初始化和屬性的變化；
過濾器(filter)：就是對請求起到過濾的作用，它在監聽器之後，作用在servlet之前，對請求進行過濾；
servlet：就是對request和response進行處理的容器，它在filter之後執行，servlet其中的一部分就是controller層（標記為servlet_2），還包括渲染視圖層(標記為servlet_3)和進入controller之前系統的一些處理部分(servlet_1)，另外我們把servlet開始的時刻標記為servlet_0，servlet結束的時刻標記為servlet_4。
攔截器(interceptor)：就是對請求和返回進行攔截，它作用在servlet的內部，具體來說有三個地方：
1）servlet_1和servlet_2之間，即請求還沒有到controller層
2）servlet_2和servlet_3之間，即請求走出controller層次，還沒有到渲染時圖層
3）servlet_3和servlet_4之間，即結束視圖渲染，但是還沒有到servlet的結束
它們之間的關係，可以用一張圖來表示：
3.使用原則
對整個流程清楚之後，然後就是各自的使用，在使用之前應該有一個使用規則，為什麼這個說，因為有些功能比如判斷用戶是否登錄，既可以用過濾器，也可以用攔截器，用哪一個才是合理的呢？那麼如果有一個原則，使用起來就會更加合理。實際上這個原則是有的：
把整個項目的流程比作一條河，那麼監聽器的作用就是能夠聽到河流里的所有聲音，過濾器就是能夠過濾出其中的魚，而攔截器則是攔截其中的部分魚，並且作標記。所以當需要監聽到項目中的一些信息，並且不需要對流程做更改時，用監聽器；當需要過濾掉其中的部分信息，只留一部分時，就用過濾器；當需要對其流程進行更改，做相關的記錄時用攔截器。下面是具體的使用案例
本文涉及到的jsp頁面：
index.jsp:
<%@ page language="java" import="com.mycompany.mvc.listener.*" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>index.jsp</title>
</head>
<body>
this is index jsp
<!-- 這裡應該填入用戶名和密碼 -->
<a href="/myWebApp/system/login">login</a>
<br></br>
測試servletcontext：
<%
application.setAttribute("app","app");
application.getAttribute("app");
application.removeAttribute("app");
%>
<br></br>
測試httpsession:
<%
session.setAttribute("app3","app3");
session.getAttribute("app3");
session.removeAttribute("app3");
%>
<br></br>
測試servletrequest:
<%
request.setAttribute("app3","app3");
request.getAttribute("app3");
request.removeAttribute("app3");
%>
<br></br>
當前在線人數：
<%=session.getAttribute("peopleOnLine")%>
<br></br>
HttpSessionBindingListener測試：
<%
session.setAttribute("bean",new myHttpSessionBindingListener());
session.removeAttribute("bean");
%>
</body>
</html>
login.jsp:
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>main.jsp</title>
</head>
<c:set var="ctx" value="${pageContext.request.scheme}://${pageContext.request.serverName}:${pageContext.request.serverPort}${pageContext.request.contextPath}" />
<script type="text/javascript" src="${ctx}/plugins/jquery-3.0.0/jquery-3.0.0.js"></script>
<script type="text/javascript">
</script>
<body>
This is has login jsp
<a href="/myWebApp/system/view">view</a>
</body>
</html>
view.jsp:
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>view jsp</title>
</head>
<body>
用戶已經登陸，歡迎來到登陸後系統主界面
</body>
</html>
4.監聽器
4.1listener具體分為八種，能夠監聽包括request域，session域，application域的產生，銷毀和屬性的變化；
具體使用，可以看之前轉載一篇文章（再次感謝"孤傲蒼狼"，他的主頁http://www.cnblogs.com/xdp-gacl/）：http://blog.csdn.net/Jintao_Ma/article/details/51464124
在配置完然後我們在web.xml中諸如下面的配置即可：
<listener> <listener-class>
com.mycompany.mvc.listener.myServletContextListener
</listener-class>
</listener>
<listener>
<listener-class>
com.mycompany.mvc.listener.myServletContextAttributeListener
</listener-class>
</listener>
4.2 listener實際應用
4.2.1 獲取當前在線人數
package com.mycompany.mvc.listener;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
public class myHttpSessionListener implements HttpSessionListener{
public static int peopleOnLine = 0;
@Override
public void sessionCreated(HttpSessionEvent arg0) {
System.out.println("myHttpSessionListener.sessionCreated():"+arg0);
peopleOnLine++;
arg0.getSession().setAttribute("peopleOnLine",peopleOnLine);
}
@Override
public void sessionDestroyed(HttpSessionEvent arg0) {
System.out.println("myHttpSessionListener.sessionDestroyed():"+arg0);
peopleOnLine--;
arg0.getSession().setAttribute("peopleOnLine",peopleOnLine);
}
}
在頁面中就可以獲取：
- 當前在線人數：
- <%=session.getAttribute("peopleOnLine")%>
其實也可以獲得歷史所有在線人數，只需要把歷史所有在線人數保存在文件中，然後每次項目啟動讀取這個文件，當前人數增加時，把歷史所有人數也相應增加，項目關閉時，再保存起來。
4.2.2 在系統初始化時，獲取項目絕對路徑
如下，獲得絕對路徑後保存到系統變數System中：
@Override
public void contextInitialized(ServletContextEvent servletContext) {
System.out.println("myServletContextListener.contextInitialized()");
System.setProperty("realPath", servletContext.getServletContext().getRealPath("/"));
System.out.println("myServletContextListener.contextInitialized()");
}
5.過濾器(filter)
5.1過濾器只需要繼承javax.servlet.filter即可，一般來說我們只要添加tomcat運行時環境就能夠包含javax.servlet的jar包，但是eclipse在tomcat8中沒有找到，實際上tomcat8中確實沒有，只有通過maven來添加了：
<!-- https://mvnrepository.com/artifact/javax.servlet/servlet-api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.servlet/jsp-api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jsp-api</artifactId>
<version>2.0</version>
</dependency>
5.2 filter的實際應用
5.2.1 請求編碼轉換
package com.mycompany.mvc.filter;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class urlEncodeFilter implements Filter{
Logger logger = LoggerFactory.getLogger(urlEncodeFilter.class);
Map<String,Object> paramMap = new HashMap<String,Object>();
@Override
public void destroy() {
}
@Override
public void doFilter(ServletRequest arg0, ServletResponse arg1,
FilterChain arg2) throws IOException, ServletException {
System.out.println("urlEncodeFilter doFilter..."+paramMap.get("urlEncode").toString());
arg0.setCharacterEncoding(paramMap.get("urlEncode").toString());
arg2.doFilter(arg0, arg1);
}
@Override
public void init(FilterConfig arg0) throws ServletException {
String urlEncode = arg0.getInitParameter("urlEncode");
paramMap.put("urlEncode",urlEncode);
}
}
web.xml配置：
<filter>
<filter-name>urlEncodeFilter</filter-name>
<filter-class>com.mycompany.mvc.filter.urlEncodeFilter</filter-class>
<init-param>
<param-name>urlEncode</param-name>
<param-value>UTF-8</param-value>
</init-param>
- </filter>
<filter-mapping>
<filter-name>urlEncodeFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
5.2.2 日誌記錄，比如記錄所有對網站發起請求的地址
package com.mycompany.mvc.filter;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class logFilter implements Filter{
Logger logger = LoggerFactory.getLogger(logFilter.class);
@Override
public void destroy() {
}
@Override
public void doFilter(ServletRequest arg0, ServletResponse arg1,
FilterChain arg2) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest)arg0;
System.out.println("logFilter doFilter servletPath:"+request.getRemoteHost());
arg2.doFilter(arg0, arg1);
}
@Override
public void init(FilterConfig arg0) throws ServletException {
}
}
web.xml:
<filter>
<filter-name>logFilter</filter-name>
<filter-class>com.mycompany.mvc.filter.logFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>logFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
5.2.3 對未登陸用戶的判斷
package com.mycompany.mvc.filter;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.apache.commons.lang.StringUtils;
import com.mycompany.mvc.utils.Constant;
public class loginFilter implements Filter{
private String dispatchUrl = "";
private String excludeUrl = "";
@Override
public void destroy() {
}
@Override
public void doFilter(ServletRequest arg0, ServletResponse arg1, FilterChain arg2)
throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest)arg0;
String servletPath = request.getServletPath();
HttpSession session = request.getSession();
String sessionKey = (String) session.getAttribute(Constant.SESSIONKEY);
/*就是登陸界面不進行過濾*/
if(servletPath.equals(dispatchUrl) || servletPath.equals(excludeUrl)){
arg2.doFilter(arg0, arg1);
}else{
if(!StringUtils.isEmpty(sessionKey)){
arg2.doFilter(arg0, arg1);
}else{
request.getRequestDispatcher(dispatchUrl).forward(arg0, arg1);
}
}
}
@Override
public void init(FilterConfig arg0) throws ServletException {
dispatchUrl = arg0.getInitParameter("dispatchUrl");
excludeUrl = arg0.getInitParameter("excludeUrl");
}
}
web.xml:
<filter>
<filter-name>loginFilter</filter-name>
<filter-class>com.mycompany.mvc.filter.loginFilter</filter-class>
<init-param>
<!-- 不進行過濾的url，因為它就是跳轉到登陸界面, -->
<param-name>excludeUrl</param-name>
<param-value>/main</param-value>
</init-param>
<init-param>
<!-- 未登錄用戶跳轉的url -->
<param-name>dispatchUrl</param-name>
<param-value>/system/login</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>loginFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
之所以上面的/main能夠直接跳轉到index這個登陸界面，是因為SpringMvc中配置了這個（上篇文章有講述到）：
<mvc:view-controller path="${adminPath}" view-name="index"/>
它的意思就是不經過controller層，直接把index放入ModelAndView，然後由渲染層進行渲染。 講到這裡，再結合上面說到的攔截器，我們發現，這個時候攔截器還是能夠攔截2次的，就是視圖渲染前和渲染後，但是進入controller層之前肯定攔截不到了，因為請求根本就沒有進入controller。
systemAction:
package com.mycompany.system.controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
@Controller
@RequestMapping("/system")
public class systemAction {
@RequestMapping("/login")
public ModelAndView login(HttpServletRequest request){
ModelAndView mv = new ModelAndView();
HttpSession session = request.getSession();
/*假設用戶輸入的用戶名密碼正確，則放入sessionKey中，對應的value可以
* 是User對象，這裡以字元串"test"代替*/
session.setAttribute("sessionKey","test");
mv.setViewName("login");
return mv;
}
@RequestMapping("/view")
public ModelAndView view(HttpServletRequest request){
ModelAndView mv = new ModelAndView();
mv.setViewName("view");
return mv;
}
}
Constant.java:
package com.mycompany.mvc.utils;
public class Constant {
public static final String SESSIONKEY = "sessionKey";
}
6.攔截器(interceptor)
6.1 攔截器這個要詳細講述一下了，上一篇文章說到，Spring的配置文件應該掃描service層及以下，SpringMvc的配置文件應該掃描controller層； 我們在service層如果想做日誌的話，可以使用spring aop特性，在spring.xml中配置aspect即可，那麼如果想在controller層做日誌，相應地，在SpringMvc.xml中應該怎麼配置呢？
這個時候就需要攔截器，它其實也是一種aop的實現(aop本身是一種思想)，而且這種實現本質上和aspect是一樣的，只是做了更多的事情，我們當然可以在SpringMvc.xml中也配置aspect，不過現在有一個更好的實現，為什麼不用呢。
關於攔截器細節，可以參考這篇文章：http://elim.iteye.com/blog/1750680
6.2 攔截器的實際應用
6.2.1 可以全局做日誌
package com.mycompany.mvc.interceptor;
import java.lang.reflect.Method;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
/**@Description
* logInterceptor公共攔截器，做日誌記錄
*/
public class logInterceptor implements HandlerInterceptor{
@Override
public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3)
throws Exception {
/*做一些清理工作*/
}
@Override
public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3)
throws Exception {
System.out.println("logInterceptor.postHandle()---view Name:"+arg3.getViewName());
}
@Override
public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {
/*取得調用的controller方法等*/
if(arg2 instanceof HandlerMethod){
HandlerMethod hMethod = (HandlerMethod)arg2;
Method method = hMethod.getMethod();
System.out.println("logInterceptor.preHandle()--method Name:"+method.getName());
}
return true;
}
}
6.2.2 記錄部分調用的時間
package com.mycompany.mvc.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
/**@Description
* 登陸時間攔截器，記錄用戶登錄時間
* */
public class timeInterceptor implements HandlerInterceptor{
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
throws Exception {
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception {
System.out.println("timeInterceptor.postHandle()--time:"+System.currentTimeMillis());
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
throws Exception {
}
}
上述兩個攔截器功能的配置如下，SpringMvc.xml:
<!-- 攔截器配置 -->
<mvc:interceptors>
<bean class="com.mycompany.mvc.interceptor.logInterceptor"></bean>
<mvc:interceptor>
<mvc:mapping path="/system/view"/>
<bean class="com.mycompany.mvc.interceptor.timeInterceptor"></bean>
</mvc:interceptor>
</mvc:interceptors>
推薦閱讀：