過濾器和攔截器的執行順序

① 過濾器和SpringMVC的攔截器的區別

過濾器和攔截器的區別：

①攔截器是基於Java的反射機制的，而過濾器是基於函數回調。
②攔截器不依賴與servlet容器，過濾器依賴與servlet容器。
③攔截器只能對action請求起作用，而過濾器則可以對幾乎所有的請求起作用。
④攔截器可以訪問action上下文、值棧里的對象，而過濾器不能訪問。
⑤在action的生命周期中，攔截器可以多次被調用，而過濾器只能在容器初始化時被調用一次。

⑥攔截器可以獲取IOC容器中的各個bean，而過濾器就不行，這點很重要，在攔截器里注入一個service，可以調用業務邏輯。

寫了點測試代碼，順便整理一下思路，搞清楚這幾者之間的順序：

1.過濾器是JavaEE標准，採用函數回調的方式進行。是在請求進入容器之後，還未進入Servlet之前進行預處理，並且在請求結束返回給前端這之間進行後期處理。

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
System.out.println("before...");
chain.doFilter(request, response);
System.out.println("after...");
}

chain.doFilter(request, response);這個方法的調用作為分水嶺。事實上調用Servlet的doService()方法是在chain.doFilter(request, response);這個方法中進行的。

2.攔截器是被包裹在過濾器之中的。

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("preHandle");
return true;
}

@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");
}

a.preHandle()這個方法是在過濾器的chain.doFilter(request, response)方法的前一步執行，也就是在 [System.out.println("before...")][chain.doFilter(request, response)]之間執行。

b.preHandle()方法之後，在returnModelAndView之前進行，可以操控Controller的ModelAndView內容。

c.afterCompletion()方法是在過濾器返回給前端前一步執行，也就是在[chain.doFilter(request, response)][System.out.println("after...")]之間執行。

3.SpringMVC的機制是由同一個Servlet來分發請求給不同的Controller，其實這一步是在Servlet的service()方法中執行的。所以過濾器、攔截器、service()方法，dispatc()方法的執行順序應該是這樣的，大致畫了個圖：其實非常好測試，自己寫一個過濾器，一個攔截器，然後在這些方法中都加個斷點，一路F8下去就得出了結論。

② 過濾器和攔截器的區別

1、首先要明確什麼是攔截器、什麼是過濾器
1.1 什麼是攔截器：
攔截器，在AOP（Aspect-Oriented Programming）中用於在某個方法或欄位被訪問之前，進行攔截然後在之前或之後加入某些操作。攔截是AOP的一種實現策略。
在Webwork的中文文檔的解釋為——攔截器是動態攔截Action調用的對象。它提供了一種機制可以使開發者可以定義在一個action執行的前後執行的代碼，也可以在一個action執行前阻止其執行。同時也是提供了一種可以提取action中可重用的部分的方式。
談到攔截器，還有一個詞大家應該知道——攔截器鏈（Interceptor Chain，在Struts 2中稱為攔截器棧 Interceptor Stack）。攔截器鏈就是將攔截器按一定的順序聯結成一條鏈。在訪問被攔截的方法或欄位時，攔截器鏈中的攔截器就會按其之前定義的順序被調用。
1.2. 攔截器的實現原理：
大部分時候，攔截器方法都是通過代理的方式來調用的。Struts 2的攔截器實現相對簡單。當請求到達Struts 2的ServletDispatcher時，Struts 2會查找配置文件，並根據其配置實例化相對的攔截器對象，然後串成一個列表（list），最後一個一個地調用列表中的攔截器。
1.3 什麼是過濾器
過濾器是一個程序，它先於與之相關的servlet或JSP頁面運行在伺服器上。過濾器可附加到一個或多個servlet或JSP頁面上，並且可以檢查進入這些資源的請求信息。在這之後，過濾器可以作如下的選擇：
①以常規的方式調用資源（即，調用servlet或JSP頁面）。
②利用修改過的請求信息調用資源。
③調用資源，但在發送響應到客戶機前對其進行修改。
④阻止該資源調用，代之以轉到其他的資源，返回一個特定的狀態代碼或生成替換輸出。

1.4 Servlet過濾器的基本原理
在Servlet作為過濾器使用時，它可以對客戶的請求進行處理。處理完成後，它會交給下一個過濾器處理，這樣，客戶的請求在過濾鏈里逐個處理，直到請求發送到目標為止。例如，某網站里有提交「修改的注冊信息」的網頁，當用戶填寫完修改信息並提交後，伺服器在進行處理時需要做兩項工作：判斷客戶端的會話是否有效；對提交的數據進行統一編碼。這兩項工作可以在由兩個過濾器組成的過濾鏈里進行處理。當過濾器處理成功後，把提交的數據發送到最終目標；如果過濾器處理不成功，將把視圖派發到指定的錯誤頁面。

2、攔截器與過濾器的區別 ：
1. 攔截器是基於java的反射機制的，而過濾器是基於函數回調。
2. 攔截器不依賴與servlet容器，過濾器依賴與servlet容器。
3. 攔截器只能對action請求起作用，而過濾器則可以對幾乎所有的請求起作用。
4. 攔截器可以訪問action上下文、值棧里的對象，而過濾器不能訪問。
5. 在action的生命周期中，攔截器可以多次被調用，而過濾器只能在容器初始化時被調用一次

③ spring mvc攔截器 和 過濾器哪個先執行

先執行filter,只有限制性過濾器之後才可以進入容器執行攔截

④ Spring filter和攔截器的區別和執行順序

Filter的執行順序跟你配置的執行順序是一樣的，執行的話要觸發到才會執行啊
當然要是過濾/*就跟配置順序一樣了

⑤ java web 過濾器跟攔截器的區別和使用

區別如下：

1 、攔截器是基於java的反射機制的，而過濾器是基於函數回調。

2 、攔截器不依賴與servlet容器，過濾器依賴與servlet容器。

3 、攔截器只能對action請求起作用，而過濾器則可以對幾乎所有的請求起作用。

4 、攔截器可以訪問action上下文、值棧里的對象，而過濾器不能訪問。

5 、在action的生命周期中，攔截器可以多次被調用，而過濾器只能在容器初始化時被調用一次。

使用如下：

在Servlet作為過濾器使用時，它可以對客戶的請求進行處理。處理完成後，它會交給下一個過濾器處理，這樣，客戶的請求在過濾鏈里逐個處理，直到請求發送到目標為止。例如，某網站里有提交「修改的注冊信息」的網頁，當用戶填寫完修改信息並提交後，伺服器在進行處理時需要做兩項工作：判斷客戶端的會話是否有效；對提交的數據進行統一編碼。

這兩項工作可以在由兩個過濾器組成的過濾鏈里進行處理。當過濾器處理成功後，把提交的數據發送到最終目標；如果過濾器處理不成功，將把視圖派發到指定的錯誤頁面。

(5)過濾器和攔截器的執行順序擴展閱讀：

攔截器，在AOP（Aspect-Oriented Programming）中用於在某個方法或欄位被訪問之前，進行攔截然後在之前或之後加入某些操作。攔截是AOP的一種實現策略。

在Webwork的中文文檔的解釋為——攔截器是動態攔截Action調用的對象。它提供了一種機制可以使開發者可以定義在一個action執行的前後執行的代碼，也可以在一個action執行前阻止其執行。同時也是提供了一種可以提取action中可重用的部分的方式。

過濾器是一個程序，它先於與之相關的servlet或JSP頁面運行在伺服器上。過濾器可附加到一個或多個servlet或JSP頁面上，並且可以檢查進入這些資源的請求信息。

⑥ java中攔截器 過濾器 監聽器都有什麼區別尤其是攔截器和過濾器

過濾器，是在java web中，你傳入的request,response提前過濾掉一些信息，或者提前設置一些參數，然後再傳入servlet或者struts2的
action進行業務邏輯，比如過濾掉非法url（不是login.do的地址請求，如果用戶沒有登陸都過濾掉）,或者在傳入servlet或者
struts2的action前統一設置字元集，或者去除掉一些非法字元
攔截器，是在面向切面編程的就是在你的service或者一個方法，前調用一個方法，或者在方法後調用一個方法比如動態代理就是攔截器的簡單實現，在你調用方法前列印出字元串（或者做其它業務邏輯的操作），也可以在你調用方法後列印出字元串，甚至在你拋出異常的時候做業務邏輯的操作。

攔截器與過濾器的區別 ：
攔截器是基於java的反射機制的，而過濾器是基於函數回調。
攔截器不依賴與servlet容器，過濾器依賴與servlet容器。
攔截器只能對action請求起作用，而過濾器則可以對幾乎所有的請求起作用。
攔截器可以訪問action上下文、值棧里的對象，而過濾器不能訪問。
在action的生命周期中，攔截器可以多次被調用，而過濾器只能在容器初始化時被調用一次
執行順序 ：過濾前 - 攔截前 - Action處理 - 攔截後 -
過濾後。個人認為過濾是一個橫向的過程，首先把客戶端提交的內容進行過濾(例如未登錄用戶不能訪問內部頁面的處理)；過濾通過後，攔截器將檢查用戶提交數
據的驗證，做一些前期的數據處理，接著把處理後的數據發給對應的Action；Action處理完成返回後，攔截器還可以做其他過程，再向上返回到過濾器的後續操作。

監聽器：這個東西在c/s模式裡面經常用到，他會對特定的事件產生產生一個處理。監聽在很多模式下用到。比如說觀察者模式，就是一個監聽來的。又比如struts2可以用監聽來啟動。Servlet監聽器用於監聽一些重要事件的發生，監聽器對象可以在事情發生前、發生後可以做一些必要的處理。
好比如果說Servlet的監聽器Listener，它是實現了javax.servlet.ServletContextListener
介面的伺服器端程序，它也是隨web應用的啟動而啟動，只初始化一次，隨web應用的停止而銷毀。主要作用是：
做一些初始化的內容添加工作、設置一些基本的內容、比如一些參數或者是一些固定的對象等等。

⑦ filter過濾器 和攔截器的區別

1、首先要明確什麼是攔截器、什麼是過濾器
1.1 什麼是攔截器：
攔截器，在AOP（Aspect-Oriented Programming）中用於在某個方法或欄位被訪問之前，進行攔截然後在之前或之後加入某些操作。攔截是AOP的一種實現策略。
在Webwork的中文文檔的解釋為——攔截器是動態攔截Action調用的對象。它提供了一種機制可以使開發者可以定義在一個action執行的前後執行的代碼，也可以在一個action執行前阻止其執行。同時也是提供了一種可以提取action中可重用的部分的方式。
談到攔截器，還有一個詞大家應該知道——攔截器鏈（Interceptor Chain，在Struts 2中稱為攔截器棧 Interceptor Stack）。攔截器鏈就是將攔截器按一定的順序聯結成一條鏈。在訪問被攔截的方法或欄位時，攔截器鏈中的攔截器就會按其之前定義的順序被調用。
1.2. 攔截器的實現原理：
大部分時候，攔截器方法都是通過代理的方式來調用的。Struts 2的攔截器實現相對簡單。當請求到達Struts 2的ServletDispatcher時，Struts 2會查找配置文件，並根據其配置實例化相對的攔截器對象，然後串成一個列表（list），最後一個一個地調用列表中的攔截器。
1.3 什麼是過濾器
過濾器是一個程序，它先於與之相關的servlet或JSP頁面運行在伺服器上。過濾器可附加到一個或多個servlet或JSP頁面上，並且可以檢查進入這些資源的請求信息。在這之後，過濾器可以作如下的選擇：
①以常規的方式調用資源（即，調用servlet或JSP頁面）。
②利用修改過的請求信息調用資源。
③調用資源，但在發送響應到客戶機前對其進行修改。
④阻止該資源調用，代之以轉到其他的資源，返回一個特定的狀態代碼或生成替換輸出。

1.4 Servlet過濾器的基本原理
在Servlet作為過濾器使用時，它可以對客戶的請求進行處理。處理完成後，它會交給下一個過濾器處理，這樣，客戶的請求在過濾鏈里逐個處理，直到請求發送到目標為止。例如，某網站里有提交「修改的注冊信息」的網頁，當用戶填寫完修改信息並提交後，伺服器在進行處理時需要做兩項工作：判斷客戶端的會話是否有效；對提交的數據進行統一編碼。這兩項工作可以在由兩個過濾器組成的過濾鏈里進行處理。當過濾器處理成功後，把提交的數據發送到最終目標；如果過濾器處理不成功，將把視圖派發到指定的錯誤頁面。

2、攔截器與過濾器的區別 ：
1. 攔截器是基於java的反射機制的，而過濾器是基於函數回調。
2. 攔截器不依賴與servlet容器，過濾器依賴與servlet容器。
3. 攔截器只能對action請求起作用，而過濾器則可以對幾乎所有的請求起作用。
4. 攔截器可以訪問action上下文、值棧里的對象，而過濾器不能訪問。
5. 在action的生命周期中，攔截器可以多次被調用，而過濾器只能在容器初始化時被調用一次

攔截器的代碼實現(以struts2為例)：
1、在xml文件中如何定義攔截器
<interceptors>
<interceptor name="filterIPInterceptor"
class="com.xxxx.web.FilterIPActionInterceptor" />
<interceptor-stack name="filterIPStack">
<interceptor-ref name="defaultStack" />

<interceptor-ref name="filterIPInterceptor" />
</interceptor-stack>
</interceptors>

2、怎麼遍別寫自定義攔截器

public class FilterIPActionInterceptor extends AbstractInterceptor
{
/** 日誌控制. */
private final Log log = LogFactory.getLog(getClass());

/**
* @see com.opensymphony.xwork2.interceptor.AbstractInterceptor#intercept(com.opensymphony.xwork2.ActionInvocation)
*/
@Override
@SuppressWarnings("unchecked")
public String intercept(ActionInvocation invocation) throws Exception
{
String result = null;
// 獲得當前方法名.
String methodName = invocation.getInvocationContext().getName();
String currIp = null;
try
{
if (invocation.getAction() instanceof PortletAction)
{
PortletAction action = (PortletAction) invocation.getAction();
currIp = action.getRequest().getRemoteAddr();
}
String ip = ApplicationResource.getHotValue("ALLOW_CACHE_IP");

if (StringUtils.isBlank(ip) || StringUtils.isBlank(currIp))
{
log.error("允許刷新的IP不存在或當前請求的IP非法.");
throw new NoAllowIPException();
}
else
{
String[] ips = ip.split(",");
boolean errorIp = true;
for (String s : ips)
{
if (s.equals(currIp))
errorIp = false;
}
// 判斷IP
if (errorIp)
throw new NoAllowIPException();
}
result = invocation.invoke();//調用被攔截的方法
}
catch (Exception e)
{
log.error("異常類名:" + invocation.getAction().getClass());
log.error("異常方法:" + methodName, e);
throw e;
}

return result;
}

}

3、怎麼編寫過濾器

1、在web.xml裡面配置自定義的攔截器
<filter>
<filter-name>Redirect Filter</filter-name>
<filter-class>com.xx.filter.RedirectFilter</filter-class>
</filter>

<filter-mapping>
<filter-name>Redirect Filter</filter-name>
<url-pattern>/xx/xx/*</url-pattern>

</filter-mapping>

2、如何編寫自定義的攔截器
public class RedirectFilter implements Filter {
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain filterChain) throws IOException, ServletException {
// 獲取URL
Long startTime = null;
if (log.isDebugEnabled())
{
startTime = System.currentTimeMillis();
}
HttpServletRequest httpRequest = (HttpServletRequest) request;
String url = httpRequest.getRequestURL().toString();
if (url == null || url.trim().length() == 0) {
return;
}
if (url.indexOf(luceneCreateMapping) != -1
|| url.indexOf(luceneSearchMapping) != -1) {
doFilterForxxx(request, response, url);
} else {
doxxxx(request, response, url);
}
if (log.isDebugEnabled())
{
long endTime = System.currentTimeMillis();
Thread currentThread = Thread.currentThread();
String threadName = currentThread.getName();
log.debug("[" + threadName + "]" + "< "
+ this.getClass().getName() + " " + url + " "
+ (endTime - startTime) + " ms");
}
// 激活下一個Filter
filterChain.doFilter(request, response);

}
}

⑧ Spring filter和攔截器的區別和執行順序

1.Filter過濾器只過濾jsp文件不過濾action請求解決方案

解決辦法：在web.xml中將filter的配置放在struts2配置的前面。

2.攔截器與Filter的區別

spring的攔截器與Servlet的Filter有相似之處，比如二者都是AOP編程思想的體現，都能實現許可權檢查、日誌記錄等。不同的是：

使用范圍不同：Filter是Servlet規范規定的，只能用於Web程序中。而攔截器既可以用於Web程序，也可以用於Application、Swing程序中。

規范不同：Filter是在Servlet規范中定義的，是Servlet容器支持的。而攔截器是在Spring容器內的，是Spring框架支持的。

使用的資源不同：同其他的代碼塊一樣，攔截器也是一個Spring的組件，歸Spring管理，配置在Spring文件中，因此能使用Spring里的任何資源、對象，例如Service對象、數據源、事務管理等，通過IoC注入到攔截器即可；而Filter則不能。

深度不同：Filter在只在Servlet前後起作用。而攔截器能夠深入到方法前後、異常拋出前後等，因此攔截器的使用具有更大的彈性。所以在Spring構架的程序中，要優先使用攔截器。

實際上Filter和Servlet極其相似，區別只是Filter不能直接對用戶生成響應。實際上Filter里doFilter()方法里的代碼就是從多個Servlet的service()方法里抽取的通用代碼，通過使用Filter可以實現更好的復用。

filter是一個可以復用的代碼片段，可以用來轉換HTTP請求、響應和頭信息。Filter不像Servlet，它不能產生一個請求或者響應，它只是修改對某一資源的請求，或者修改從某一的響應。

JSR中說明的是，按照多個匹配的Filter，是按照其在web.xml中配置的順序來執行的。

所以這也就是，把自己的Filter或者其他的Filter（比如UrlRewrite的Filter）放在Struts的DispatcherFilter的前面的原因。因為，它們需要在請求被Struts2框架處理之前，做一些前置的工作。

當Filter被調用，並且進入了Struts2的DispatcherFilter中後，Struts2會按照在Action中配置的InterceptorStack中的Interceptor的順序，來調用Interceptor。

3.servlet、filter、interceptor的執行順序

@Override
publicvoiddoFilter(ServletRequestservletrequest,
,FilterChainfilterchain)
throwsIOException,ServletException{
System.out.println("infilter1.");
filterchain.doFilter(servletrequest,servletresponse);
System.out.println("outingfilter1");
}

interceptor代碼：

publicStringintercept()throwsException{
System.out.println("inlogininterceptor");
Stringresult=actioninvocation.invoke();
System.out.println("outinglogininterceptor");
returnresult;
}

action代碼：

@Override
publicStringexecute()throwsException{
System.out.println("inloginaciton");
ActionContextcontext=ActionContext.getContext();
Map<String,Object>session=context.getSession();
session.put("userName",userName);

/*HttpServletRequestrequest=ServletActionContext.getRequest();
HttpSessionsession=request.getSession();
session.putValue("userName",userName);*/
System.out.println("outingloginaciton");
returnSUCCESS;
}

jsp代碼：

<scripttype="text/javascript">
functionsubmitForm(){
document.getElementById("form1").submit();
}
</script>

</head>

<body>
ThisisLoginpage.<br>
<formaction="<%=path%>/login2.action"method="post"id="form1"name="form1">
UserName:<inputtype="text"id="userName"name="userName"/><inputtype="button"value="submit"onclick="submitForm()"id="submit1"/>
</form>
</body>

struts.xml

<struts>
<packagename="default"extends="struts-default"namespace="/">

<interceptors>
<interceptorname="MyInterceptor"class="Login.LoginInterceptor"></interceptor>
<interceptor-stackname="myInterceptorStack">
<interceptor-refname="MyInterceptor"/>
<interceptor-refname="defaultStack"/>
</interceptor-stack>
</interceptors>

<actionname="login2"class="Login.LoginAction">
<resultname="success">
/Login/success.jsp
</result>
<interceptor-refname="myInterceptorStack"></interceptor-ref>
</action>

</package>
</struts>

console:

infilter1.
inlogininterceptor
inloginaciton
outingloginaciton
outinglogininterceptor
outingfilter1

3.servlet、filter的執行順序

servlet代碼：

publicvoidinit()throwsServletException{
System.out.println("servlet初始化");
}

publicvoiddoPost(HttpServletRequestrequest,HttpServletResponseresponse)
throwsServletException,IOException{
System.out.println("inservlet");
response.setContentType("text/html");
PrintWriterout=response.getWriter();
out.println("<!DOCTYPEHTMLPUBLIC"-//W3C//DTDHTML4.01Transitional//EN">");
out.println("<HTML>");
out.println("<HEAD><TITLE>AServlet</TITLE></HEAD>");
out.println("<BODY>");
out.print("Thisis");
out.print(this.getClass());
out.println(",usingthePOSTmethod");

out.println("<br>");
Stringx=request.getParameter("x");
Stringy=request.getParameter("y");
out.println("x="+x);
out.println("<br>");
out.println("y="+y);
out.println("<br>");

out.println("</BODY>");
out.println("</HTML>");
out.flush();
out.close();
System.out.println("outingservlet");
}

publicvoiddestroy(){
System.out.println("servlet銷毀");
super.destroy();
}

console:

servlet初始化
infilter1.
inservlet
beforeHttpServletRequest
afterHttpServletRequest
outingservlet
outingfilter1
當tomcat容器停止的時候，輸出:servlet銷毀

⑨ filter跟攔截器的區別和執行順序

filter和攔截器的區別和執行順序

1.Filter過濾器只過濾jsp文件不過濾action請求解決方案

解決辦法：在web.xml中將filter的配置放在struts2配置的前面。

2.攔截器與Filter的區別
Spring的攔截器與Servlet的Filter有相似之處，比如二者都是AOP編程思想的體現，都能實現許可權檢查、日誌記錄等。不同的是：

使用范圍不同：Filter是Servlet規范規定的，只能用於Web程序中。而攔截器既可以用於Web程序，也可以用於Application、Swing程序中。

規范不同：Filter是在Servlet規范中定義的，是Servlet容器支持的。而攔截器是在Spring容器內的，是Spring框架支持的。

使用的資源不同：同其他的代碼塊一樣，攔截器也是一個Spring的組件，歸Spring管理，配置在Spring文件中，因此能使用Spring里的任何資源、對象，例如Service對象、數據源、事務管理等，通過IoC注入到攔截器即可；而Filter則不能。

深度不同：Filter在只在Servlet前後起作用。而攔截器能夠深入到方法前後、異常拋出前後等，因此攔截器的使用具有更大的彈性。所以在Spring構架的程序中，要優先使用攔截器。

實際上Filter和Servlet極其相似，區別只是Filter不能直接對用戶生成響應。實際上Filter里doFilter()方法里的代碼就是從多個Servlet的service()方法里抽取的通用代碼，通過使用Filter可以實現更好的復用。
filter是一個可以復用的代碼片段，可以用來轉換HTTP請求、響應和頭信息。Filter不像Servlet，它不能產生一個請求或者響 應，它只是修改對某一資源的請求，或者修改從某一的響應。
JSR中說明的是，按照多個匹配的Filter，是按照其在web.xml中配置的順序 來執行的。

所以這也就是，把自己的Filter或者其他的Filter（比如UrlRewrite的Filter）放在Struts的 DispatcherFilter的前面的原因。因為，它們需要在請求被Struts2框架處理之前，做一些前置的工作。

當Filter被調用，並且進入了Struts2的DispatcherFilter中 後，Struts2會按照在Action中配置的Interceptor Stack中的Interceptor的順序，來調用Interceptor。

⑩ SpringMVC的攔截器和過濾器的區別與聯系

首先給介紹下過濾器和攔截器的區別：
（1）攔截器是基於Java的反射機制的，而過濾器是基於函數回調。
（2）攔截器不依賴與servlet容器，過濾器依賴與servlet容器。
（3）攔截器只能對action請求起作用，而過濾器則可以對幾乎所有的請求起作用。
（4）攔截器可以訪問action上下文、值棧里的對象，而過濾器不能訪問。
（5）在action的生命周期中，攔截器可以多次被調用，而過濾器只能在容器初始化時被調用一次。
（6）攔截器可以獲取IOC容器中的各個bean，而過濾器就不行，這點很重要，在攔截器里注入一個service，
可以調用業務邏輯。
然後進行分析下：
1.過濾器是JavaEE標准，採用函數回調的方式進行。是在請求進入容器之後，還未進入Servlet之前進行預處
理，並且在請求結束返回給前端這之間進行後期處理。

@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
System.out.println("before...");
chain.doFilter(request, response);
System.out.println("after...");
}

chain.doFilter(request, response);這個方法的調用作為分水嶺。事實上調用Servlet的doService()方法是在
chain.doFilter(request, response);這個方法中進行的。

2.攔截器是被包裹在過濾器之中的。

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("preHandle");
return true;
}

@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");
}

a.preHandle()這個方法是在過濾器的chain.doFilter(request, response)方法的前一步執行，也就是在
[System.out.println("before...")][chain.doFilter(request, response)]之間執行。
b.preHandle()方法之後，在return ModelAndView之前進行，可以操控Controller的ModelAndView內容。
c.afterCompletion()方法是在過濾器返回給前端前一步執行，也就是在[chain.doFilter(request, response)]
[System.out.println("after...")]之間執行。
3.SpringMVC的機制是由同一個Servlet來分發請求給不同的Controller，其實這一步是在Servlet的service()方法
中執行的。所以過濾器、攔截器、service()方法，dispatc()方法的執行順序應該是這樣的如下圖: