struts2方法前過濾器_Java框架Struts2的攔截器和過濾器有什麼區別

Ⅰ Struts2中過濾器和攔截器的區別

過濾器是在javaweb中，你傳入的request,response提前過濾掉一些信息，或者提前設置一些參數，然後再傳入servlet或者struts的action進行業務邏輯，比如過濾掉非法url（不是login.do的地址請求，如果用戶沒有登陸都過濾掉）,或者在傳入servlet或者struts的action前統一設置字元集，或者去除掉一些非法字元（如：聊天室經常用到的，一些罵人的話）
攔截器可通過的是符合條件的action。攔截器本身是一個普通的Java對象，它能動態攔截Action調用，Action執行前後執行攔截器本身提供的各種個樣的Web項目需求。也可以阻止Action的執行，同時也可以提取Action中可以復用的部分。

Ⅱ struts2 攔截器和過濾器的作用是什麼

struts2攔截器，在AOP中用於在某個方法或欄位被訪問之前，進行攔截然後在之前或之後加入某些操作。攔截是AOP的一種實現策略。過濾器是輸送介質管道上不可缺少的一種裝置，通常安裝在減壓閥、泄壓閥、定水位閥 ,方工過濾器其它設備的進口端設備。

Ⅲ struts2的過濾器配置問題

你在這個配置文件改是不能過濾的，因為它只是個XML文本文件；如果你要細化過濾你想要的東西，必須鍵一個過濾器的java文件，然後在裡面寫判斷才能實現。

Ⅳ 如何配置struts2的過濾器

你說的是攔截器吧
第一步：創建一個類實現Intercepter介面並實現其中方法
第二步：注冊攔截器（在struts.xml）如：
<package name="cust"
namespace="/cust"
extends="struts-default">
<interceptors>

<interceptor name="first"
class="com.interceptor.FirstInterceptor"/>
<interceptor name="second"
class="com.interceptor.SecondInterceptor"/>

<interceptor-stack name="mystack">
<interceptor-ref name="first"/>
<interceptor-ref name="second"/>

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


<interceptor-ref name="mystack"/>
<result name="success">
/WEB-INF/cust/update_customer.jsp
</result>
</action>
</package>
供參考

Ⅳ struts2攔截器的作用是什麼（它攔截什麼）過濾器的作用是什麼呢（過濾什麼）

攔截器只能攔截Action,說明白點攔截器其實是Action的功能塊,只在Action前後執行,初學者肯定會有疑問內,把功能全都寫在容Action中就行了呀,為什麼要把功能分出來,其實這個struts2的一個強大之處,你想想,假如這個功能塊很多Action都要用,難道你的這些Action中都要寫呀,就算復制粘貼也不方便呀,你把它做成功能塊,哪個Action需要就在哪個Action中配置就好了,更好的方法是,創建一個公共的Action,把通用的東西全配置到這裡面,其他Action引用(繼承)就可以了
過濾器是攔截用戶請求的,范圍明顯比攔截器大的多,你上網時肯定碰到過這中效果,你想下載個東西,點擊下載先跳出登陸頁面,這就是攔截器搞的鬼,沒有登錄前很多頁面或Action都被他攔截了

Ⅵ Java框架Struts2的攔截器和過濾器有什麼區別

過濾器，是在java web中，你傳入的request,response提前過濾掉一些信息，或者提前設置一些參數，然後再傳入servlet或者struts的
action進行業務邏輯，比如過濾掉非法url（不是login.do的地址請求，如果用戶沒有登陸都過濾掉）,或者在傳入servlet或者
struts的action前統一設置字元集，或者去除掉一些非法字元.

攔截器，是在面向切面編程的就是在你的service或者一個方法，前調用一個方法，或者在方法後調用一個方法比如動態代理就是攔截器的簡單實現，在你調用方法前列印出字元串（或者做其它業務邏輯的操作），也可以在你調用方法後列印出字元串，甚至在你拋出異常的時候做業務邏輯的操作。

攔截器與過濾器的區別：

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

執行順序：過濾前 - 攔截前 - Action處理 - 攔截後 -
過濾後。個人認為過濾是一個橫向的過程，首先把客戶端提交的內容進行過濾(例如未登錄用戶不能訪問內部頁面的處理)；過濾通過後，攔截器將檢查用戶提交數據的驗證，做一些前期的數據處理，接著把處理後的數據發給對應的Action；Action處理完成返回後，攔截器還可以做其他過程(還沒想到要做啥)，再向上返回到過濾器的後續操作。

Ⅶ struts2 攔截器和過濾器的作用是什麼

攔截器的工作原理：
當接收到一個httprequest ,
a) 當外部的httpservletrequest到來時
b) 初始到了servlet容器傳遞給一個標準的過濾器鏈
c) FilterDispatecher會去查找相應的ActionMapper，如果找到了相應的ActionMapper它將會將控制許可權交給ActionProxy
d) ActionProxy將會通過ConfigurationManager來查找配置struts.xml
i. 下一步將會通過ActionInvocation來負責命令模式的實現（包括調用一些攔截Interceptor框架在調用action之前）
ii. Interceptor做一些攔截或者初始的工作
e) 一旦action返回，會查找相應的Result
f) Result類型可以是 jsp或者freeMark 等
g) 這些組件和ActionMapper一起返回給請求的url（注意攔截器的執行順序）
h) 響應的返回是通過我們在web.xml中配置的過濾器
i) 如果ActionContextCleanUp是當前使用的，則FilterDispatecher將不會清理sreadlocal ActionContext;如果ActionContextCleanUp不使用，則將會去清理sreadlocals。
攔截器實現原理：

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

過濾器的作用：
(1)執行Actions
過濾器通過ActionMapper對象，來判斷是否應該被映射到Action.如果mapper對象指示他應該被映射，過濾鏈將會被終止，然後Action被調用。這一點非常重要，如果同時使用SiteMesh filter，則SiteMesh filter應該放到該過濾器前，否則Action的輸出將不會被裝飾。
(2)清除ActionContext
過濾器為了確保內存溢出，會自動的清除ActionContext。這可能會存在一些問題，在和其它的框架集成時，例如SiteMesh。ActionContextCleanUp提供了怎麼處理這些問題的一些信息。
(3)維護靜態內容
過濾器也會維護在Struts2中使用的一些公共的靜態的內容，例如JavaScript文件，CSS文件等。搜索/struts/*范圍內的請求，然後將/struts/後面的值映射到一些struts的公共包中，也可以在你的類路徑中搜索。默認情況下會去查找以下包：org.apache.struts2.static.template。這樣你只用請求/struts/xhtml/styles.css，XHTML UI主題默認的樣式表將會被返回。同樣，AJAX UI組件需要的JavaScript文件，也可以在org.apache.struts2.static包中被找到。如果你想加入其它被搜索的包，在web.xml中設置filter時，通過給"actionPackages"初始參數一個逗號隔開的包列表值來設定。

Ⅷ struts2配置過濾器與攔截器

你在過濾器中重定向的啊。我們這個項目是在攔截器中返回字元串，然後通過 struts.xml 跳轉到你要跳轉的頁面。。。。
代碼：
這是配置的攔截器。

<package name="onlyadmin" extends="struts-default">
<interceptors>

<interceptor class="e.cuit.course.interceptor.AdminInterceptor"
name="admin" />

<interceptor-stack name="adminInterceptor">

<interceptor-ref name="defaultStack" />

<interceptor-ref name="admin">
<param name="excludeMethods">list</param>
</interceptor-ref>
</interceptor-stack>
</interceptors>

<default-interceptor-ref name="adminInterceptor" />
<global-results>
<result name="login">/user/userLogin.jsp</result>
</global-results>
【這是全局的result，你就曉得，當自定義攔截器返回login的時候，它就會跳轉到你要跳轉的頁面了。】
<action name="admin" class="e.cuit.course.action.AdminAction">
</action>
<action name="mole" class="e.cuit.course.action.MoleAction">
<result name="addMole">/mole/moleadd.jsp</result>
<result name="addSuccess">/mole/suc.jsp</result>
<result name="listByPageSuccess">/page/molelist.jsp</result>
<result name="update">/mole/moleupdate.jsp</result>
<result name="updateSuccess">/mole/suc.jsp</result>
</action>

<action name="menu" class="e.cuit.course.action.MenuAction">
<result name="add">/menu/menuadd.jsp</result>
<result name="addSuccess">/menu/suc.jsp</result>
<result name="listByPageSuccess">/page/menulist.jsp</result>
<result name="update">/menu/menuupdate.jsp</result>
<result name="updateSuccess" type="redirectAction">
<param name="actionName">menu</param>
<param name="method">listByPage</param>
</result>
</action>
</package>
。。。。。。。。。。。。。。。。。。。。。。。。。。。
這就是自定義的攔截器：
package e.cuit.course.interceptor;

import java.util.Map;

import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.interceptor.MethodFilterInterceptor;

import e.cuit.course.action.UserAction;
import e.cuit.course.pojo.User;

public class UserInterceptor extends MethodFilterInterceptor {
private static final long serialVersionUID = -4390311642665624081L;

private UserAction userAction = new UserAction();
@Override
public String doIntercept(ActionInvocation invocation) throws Exception {

ActionContext ctx = invocation.getInvocationContext();

Map<String ,Object> session = ctx.getSession();

User user = (User) session.get("user");
if (user == null) {
ctx.put("loginTip", "你還沒有登錄");
return Action.LOGIN;
}
return invocation.invoke();
}

public void setUserAction(UserAction userAction) {
this.userAction = userAction;
}
public UserAction getUserAction() {
return userAction;
}
}
。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
應該差不多了，還有個system 的攔截器，差不多的結構。。要知道你提交請求的時候，先叫由web。xml然後通過過濾器一層一層到攔截器，也就是在你的邏輯前加一些驗證的東西，系統的攔截器有很多， invocation.invoke（）就是一層一層去觸發攔截器，當系統的攔截器和自定義的攔截器都通過了的時候才回訪問你的邏輯 action 或者方法，這個叫做aop編程。面向切面編程。

Ⅸ struts2攔截器和過濾器的區別

攔截器和過濾器的區別：

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

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

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

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

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

攔截器：是在面向切面編程的就是在你的service或者一個方法前調用一個方法，或者在方法後調用一個方法比如動態代理就是攔截器的簡單實現，在你調用方法前列印出字元串（或者做其它業務邏輯的操作），也可以在你調用方法後列印出字元串，甚至在你拋出異常的時候做業務邏輯的操作。

下面通過實例來看一下過濾器和攔截器的區別：

使用攔截器進行/admin 目錄下jsp頁面的過濾

[html]view plain

<packagename="newsDemo"extends="struts-default"
namespace="/admin">
<interceptors>
<interceptorname="auth"class="com.test.news.util.AccessInterceptor"/>
<interceptor-stackname="authStack">
<interceptor-refname="auth"/>
</interceptor-stack>
</interceptors>
<actionname="newsAdminView!*"class="newsAction"
method="{1}">
<interceptor-refname="defaultStack"/>
<interceptor-refname="authStack">
</interceptor-ref>

下面是我實現的Interceptor class:

[java]view plain

packagecom.test.news.util;
importjava.util.Map;
importcom.opensymphony.xwork2.ActionContext;
importcom.opensymphony.xwork2.ActionInvocation;
importcom.opensymphony.xwork2.interceptor.AbstractInterceptor;
importcom.test.news.action.AdminLoginAction;
/**
*@authorchaoyin
*/
{
=-4291195782860785705L;
@Override
publicStringintercept()throwsException{
ActionContextactionContext=actionInvocation.getInvocationContext();
Mapsession=actionContext.getSession();
//exceptloginaction
Objectaction=actionInvocation.getAction();
if(){
returnactionInvocation.invoke();
}
//checksession
if(session.get("user")==null){
return"logout";
}
returnactionInvocation.invoke();//goon
}
}

過濾器：是在javaweb中，你傳入的request,response提前過濾掉一些信息，或者提前設置一些參數，然後再傳入servlet或者struts的 action進行業務邏輯，比如過濾掉非法url（不是login.do的地址請求，如果用戶沒有登陸都過濾掉）,或者在傳入servlet或者 struts的action前統一設置字元集，或者去除掉一些非法字元.

使用過濾器進行/admin 目錄下jsp頁面的過濾，首先在web.xml進行過濾器配置:

[html]view plain

<filter>
<filter-name>accessfilter</filter-name>
<filter-class>
com.test.news.util.AccessFilter
</filter-class>
</filter>
<filter-mapping>
<filter-name>accessfilter</filter-name>
<url-pattern>/admin/*</url-pattern>
</filter-mapping>

下面是過濾的實現類:

[java]view plain

packagecom.test.news.util;
importjava.io.IOException;
importjavax.servlet.Filter;
importjavax.servlet.FilterChain;
importjavax.servlet.FilterConfig;
importjavax.servlet.ServletException;
importjavax.servlet.ServletRequest;
importjavax.servlet.ServletResponse;
importjavax.servlet.http.HttpServletRequest;
importjavax.servlet.http.HttpServletResponse;
importjavax.servlet.http.HttpSession;
{
/**
*@authorchaoyin
*/
publicvoiddestroy(){
}
publicvoiddoFilter(ServletRequestarg0,ServletResponsearg1,
FilterChainfilterChain)throwsIOException,ServletException{
HttpServletRequestrequest=(HttpServletRequest)arg0;
HttpServletResponseresponse=(HttpServletResponse)arg1;
HttpSessionsession=request.getSession();
if(session.getAttribute("user")==null&&request.getRequestURI().indexOf("login.jsp")==-1){
response.sendRedirect("login.jsp");
return;
}
filterChain.doFilter(arg0,arg1);
}
publicvoidinit(FilterConfigarg0)throwsServletException{
}
}

Ⅹ struts2過濾器

WEB.xml中配置struts2的代碼片段
<filter>
<filter-name>struts2</filter-name>
<filter-class>
org.apache.struts2.dispatcher.FilterDispatcher
</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
'/*'是攔截所有的url,你這里可以配置你的過濾規則的啊（例如/*.jsp、/*_aaa.jsp等），但是版一般不需要修改的，改權了以後，擴展起來會給你帶來一些的不必要的麻煩的

導航:首頁 > 凈水問答 > struts2方法前過濾器

struts2方法前過濾器

與struts2方法前過濾器相關的資料