Struts2框架快速入門筆記

smlxs_lbb發表於2018-04-09

框架筆記

[toc]

Struts2是一個基於MVC設計模式的Web應用框架，它本質上相當於一個servlet，在MVC設計模式中，Struts2作為控制器(Controller)來建立模型與檢視的資料互動。

Struts2=struts1+webwork

一、Struts2框架執行流程

當通過瀏覽器傳送一個請求
會被StrutsPrepareAndExecuteFilter攔截
會呼叫strtus2框架預設的攔截器(interceptor)完成部分功能
在執行Action中操作
根據Action中方法的執行結果來選擇來跳轉頁面Resutl檢視

Strtus2的預設攔截器(interceptor)它們是在struts-default.xml檔案中配置注意:這上xml檔案是在strtus-core.jar包中，預設的攔截器是在defaultStack中定義的。

二、Struts2的快速入門

匯入相關的jar檔案
需要在web.xml檔案中配置StrutsPrepareAndExecuteFilter
配置struts.xml檔案
建立Action來完成邏輯操作

1.匯入jar包

如果我們只是建立一個簡單的專案的話，不需要將它的lib包下的所有的jar檔案copy到專案中，而是使用其中的一部分。

2.配置web.xml檔案

在web.xml檔案中配置StrutsPrepareAndExecuteFilter。一般管StrutsPrepareAndExecuteFilter 叫做前端控制器(核心控制器)，只有配置了這個filter我們的strtus2框架才能使用。

<filter>
  	<!-- filter-name	可以隨便寫 -->
  	<filter-name>struts2</filter-name>
  	<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <filter-mapping>
  	<filter-name>struts2</filter-name>
  	<url-pattern>/*</url-pattern>
  </filter-mapping>
複製程式碼

3.配置struts.xml檔案

jsp頁面的程式碼

<form action="${ pageContext.request.contextPath }/LoginAction" method="post">
	賬號：<input type="text" name="username"><br/>
	密碼：<input type="password" name="password"><br/>
	<input type="submit" value="LOGIN">
</form>
<s:debug/>
複製程式碼

struts.xml檔案對應配置

<struts>

<constant name="struts.devMode" value="true"></constant>

<package name="default" namespace="/" extends="struts-default">
	<action name="LoginAction" class="com.lbb.strus2.action.LoginAction" method="login">
		<result name="success" type="redirect">/success.jsp</result>
		<result name="failer">/failter.jsp</result>
	</action>
</package>

</struts>
複製程式碼

4.建立Action來完成邏輯操作

public class LoginAction {
	private String username;
	private String password;
/*
	......
	提供屬性對應的get/set方法
	......
*/
	public String login() {
		System.out.println(username+"   "+password);
		if("tom".equals(username)&&"123".equals(password)){
			return "success";
		}else{
			return "failer";
		}
	}
	
}
複製程式碼

三、Struts2配置詳解

Struts2配置檔案載入順序

通過以下步驟可以找到載入配置檔案原始碼的位置

ps：我也不知道為什麼只有123567，沒有4

第一個載入的是default.properties檔案位置:strtus2-core.jar包 org.apache.struts2包下作用:主要是宣告瞭struts2框架的常量
第二個載入的是一批配置檔案 Strtus-default.xml 位置:struts2-corl.jar 作用:宣告瞭interceptor result bean Strtus-plugin.xml 位置:在strtus2的外掛包中作用:主要用於外掛的配置宣告 Strtus.xml 位置:在我們自己的工程中作用:用於我們自己工程使用strtus2框架的配置
第三個載入的是自定義的strtus.properties 位置:都是在自己工程的src下作用:定製常量
第四自定義配置提供第五載入的是web.xml配置檔案主要是載入strtus2框架在web.xml檔案中的相關配置. (專案最開始載入的就是web.xml，這裡是指在前四個配置檔案載入完成後，又返回來重新載入一次這個配置檔案)
第六 bean相關配置

（這裡的載入是指從硬碟載入到記憶體並進行部分的讀取，而在一個請求中進行的載入是指在記憶體中讀取配置檔案）

struts.xml檔案配置介紹

<package name="default" namespace="/" extends="struts-default">
    <action name="LoginAction" class="com.lbb.strus2.action.LoginAction" method="login">
        <result name="success" type="redirect">/success.jsp</result>
        <result name="failer">/failter.jsp</result>
    </action>
</package>
複製程式碼

package配置

name屬性作用:定義一個包的名稱，它必須唯一。
namespace屬性作用:主要是與action標籤的name屬性聯合使用來確定一個action 的訪問路徑
extends屬性作用:指定繼承自哪個包。一般值是strtus-default strtus-default包是在strtus-default.xml檔案中宣告的。
abstruct屬性它代表當前包是一個抽象的，主要是用於被繼承 <package name="struts-default" abstract="true">

action配置

name屬性作用:主要是與package的namespace聯合使用來確定一個action的訪問路徑
class屬性作用:用於指示當前的action類
method屬性作用:用於指示當前的action類中的哪個方法執行

result配置

它主要是用於指示結果檢視

name屬性作用是與action類的method方法的返回值進行匹配，來確定跳轉路徑
type屬性作用是用於指定跳轉方式（預設是請求轉發）

關於路徑跳轉問題,它的name屬性是與action中的方法的返回值進行對比的。

它的type屬性可以取哪些值?

預設值是dispatcher 它代表的是請求轉發。針對於jsp頁面 redirect 它代表的是重定向針對於jsp頁面 chain 它類似於請示轉發，只不過它是針對於action跳轉. redirectAction 它類似於重定向針對於action 關於路徑跳轉的配置可以直接在<package>下建立全域性的result

擴充套件

關於action配置中的class與method的預設值以及result中的name與type 預設值問題.

<action name="LoginAction">
     <result>/success.jsp</result>
</action>
複製程式碼

原因:strtus-default.xml檔案中配置 <default-class-ref class="com.opensymphony.xwork2.ActionSupport" /> 它的作用就是當一個請求來時，如果查詢不到指定的class及對應的method就會執行ActionSupport類中的execute方法。在這個類的execute方法中預設返回的是”success”。也就是說，result的name屬性預設值是success,預設的跳轉方式是請求轉發 dispatcher。

常量配置

在default.properties檔案中定義了struts2框架常用常量。那麼，我們怎樣可以設定常量。

可以在src下建立一個strtus.properties配置檔案
可以在web.xml檔案中配置
可以直接在strtus.xml檔案中定義常量 (推薦)

注意:後載入的配置檔案中的常量會將先載入的常量覆蓋

<!-- 宣告常量 -->
<constant name="struts.i18n.encoding" value="UTF-8"></constant>
<!-- 可以幫助我們解決post請求亂碼問題 -->
<!-- <constant name="struts.action.extension" value="action"></constant> -->
<!-- 指定訪問strtsu2框架路徑的副檔名 -->
<constant name="struts.devMode" value="true"></constant>
<!-- 配置這項後，它會提供更加詳細報錯資訊，以及在struts.xml檔案修改後不在需要重啟伺服器 -->
<constant name="struts.enable.DynamicMethodInvocation" value="true"></constant>
<!-- 開啟動態方法呼叫 -->
複製程式碼

四、Struts2的Action詳解

Struts2中的action，主要是完成業務邏輯操作。Action替代在servlet中完成的作用。

Action的學習主要有兩點

如何建立一個struts2的action
如果訪問一個struts2的action

Action類建立方式(三種)

建立一個pojo類 Pojo(plani Ordinary java object)簡單的java物件 Pojo類就是沒有實現任何介面沒有繼承任何類優點:無耦合缺點:所有的功能都要自己完成
建立一個類實現一個Action介面 com.opensymphony.xwork2.Action

在Action介面中定義了五個常量，一個execute方法。 五個常量:它們是預設的五個結果檢視<result name="">: ERROR : 錯誤檢視 INPUT: 它是struts2框架中interceptor中發現問題後會訪問的一個檢視 LOGIN:它是一個登入檢視，可以在許可權操作中使用 NONE:它代表的是null,什麼都不做（也不會做跳轉操作） SUCCESS:這是一個成功檢視優點：耦合度低缺點:還是需要自己來完成功能 3. 建立一個類繼承ActionSupport類 com.opensymphony.xwork2.ActionSupport ActionSupport類也實現了Action介面。我們在開發中一般會使用這種方案: 優點:具有豐富的功能，例如表單校驗錯誤資訊設定國際化缺點:耦合度高

Action的訪問方式

直接通過標籤來配置，通過method來指定訪問的方法，如果method沒有，預設訪問的是execute方法。
簡化的action訪問方式，可以使用*萬用字元來訪問。

<action name="Book_*" class="com.lbb.strus2.action.BookAction" method="{1}"></action>
<action name="*_*" class="com.lbb.strus2.action.{1}Action" method="{2}"></action>
複製程式碼

public class BookAction extends ActionSupport{
	public void add() {
		System.out.println("bookadd");
	}
	public void del() {
		System.out.println("bookdel");
	}
	public void update() {
		System.out.println("bookupdate");
	}
	public void find() {
		System.out.println("bookfind");
	}
}
public class ProductAction extends ActionSupport{
	public void add() {
		System.out.println("productadd");
	}
	public void del() {
		System.out.println("productdel");
	}
	public void update() {
		System.out.println("productupdate");
	}
	public void find() {
		System.out.println("productfind");
	}
}
複製程式碼

這種方式的缺點:不建議使用過多的號，它帶來程式閱讀障礙，不便於理解使用來簡化操作方案，它對名稱規範必須進行一個統一。

擴充套件--動態方法呼叫

<!-- localhost:8080/工程名/Book_add!add -->
<constant name="struts.enable.DynamicMethodInvocation" value="true"></constant>
<!-- 開啟動態方法呼叫 -->
複製程式碼

注意:對於strtus2的動態方法呼叫，要想使用我們必須配置一個常量來開啟動態方法呼叫。個人不建議使用動態方法呼叫（出現過漏洞！）

五、Struts2框架封裝資料

在action中如果獲取請求引數？主要有兩類三種方法

屬性驅動

第一種，直接在action類中提供與請求引數匹配屬性，提供get/set方法。

public class LoginAction {
	private String username;
	private String password;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String login() {
		System.out.println(username+"   "+password);
		if("tom".equals(username)&&"123".equals(password)){
			return "success";
		}else{
			return "failer";
		}
	}
}
複製程式碼

第二種，在action類中創始一個javaBean,對其提供get/set ，在請求時頁面上要進行修改，例如 user.username user.password ,要使用ognl表示式

public class LoginAction2{
	private User user = new User();
	public User getUser() {
		return user;
	}
	public void setUser(User user) {
		this.user = user;
	}
	public String login() {
		System.out.println(user.getUsername()+"   "+user.getPassword());
		if("tom".equals(user.getUsername())&&"123".equals(user.getPassword())){
			return "success";
		}else{
			return "failer";
		}
	}
}
複製程式碼

以上兩種方式的優缺點: 第一種：比較簡單，在實際操作我們需要將action的屬性在賦值給模型(javaBean) 去操作第二種：不需要在直接將值給javaBean過程，因為直接將資料封裝到了javaBean 中。它要求在頁面上必須使用ognl表示式，就存在頁面不通用問題。

模型驅動

步驟:

讓Action類要實現一個指定介面ModelDriven
例項化模型物件(就是要new出來javaBean)
重寫getModel方法將例項化的模型返回。對於模型驅動它與屬性驅動對比，在實際開發中使用比較多，模型驅動缺點，它只能對一個模型資料進行封裝。

public class LoginAction3 implements ModelDriven<User>{
	private User user = new User();
	public User getModel() {
		return user;
	}
	public String login() {
		System.out.println(user.getUsername()+"   "+user.getPassword());
		if("tom".equals(user.getUsername())&&"123".equals(user.getPassword())){
			return "success";
		}else{
			return "failer";
		}
	}
}
複製程式碼

小結

六、Struts2中獲取Servlet API

在action類中獲取request response session...物件，有兩種方案。

ServletActionContext獲取

採用注入方式

Struts2框架在執行時，請求會被StrutsPrepareAndExecuteFilter攔截，會根據請求，去 strtus.xml檔案中查詢到匹配的action，在action執行前，會走一些interceptor。

預設執行的攔截器是struts-default.xml檔案中定義的，在預設執行的攔截器中有一個

<interceptor name="servletConfig" "lass="org.apache.struts2.interceptor.ServletConfigInterceptor"/>
......
<interceptor-ref name="servletConfig"/>
複製程式碼

檢視一下ServletConfigInterceptor原始碼。以下是部分原始碼

ServletRequestAware, 實現這個介面可以獲取HttpServletRequest ServletResponseAware ,實現這個介面可以獲取HttpServletResponse ServletContextAware 實現這個介面可以獲取ServletContext

OGNL表示式

OGNL是Object-Graph Navigation Language(物件圖導航語言)的縮寫，它是一種功能強大的表示式語言，通過它簡單一致的表示式語法，可以存取物件的任意屬性，呼叫物件的方法，遍歷整個物件的結構圖，實現欄位型別轉化等功能。它使用相同的表示式去存取物件的屬性。

Strtsu2框架內建了OGNL OGNL本身也是一個專案，它是可以單獨使用。

OGNL作用 支援物件的操作，呼叫物件的方法支援靜態成員訪問支援賦值操作與表達串聯訪問OGNL上下文，訪問ActionContext 操作集合物件。

單獨使用OGNL來完成示例

OGNL三要素: 1.表示式 2.OgnlContext 上下文 3. Root 根

支援物件操作

// 表示式 OgnlContext 上下文 Root 根
@Test
public void test1() throws OgnlException {
	// String s="hello";
	// int length = s.length();
	// 1.獲取上下文物件OgnlContext
	OgnlContext context = new OgnlContext(); // 它就是一個java.util.Map
	// 2.操作
	Object root = context.getRoot();
	Object value = Ognl.getValue("'hello'.length()", context, root);
	System.out.println(value);
}
複製程式碼

支援靜態成員訪問

// 1.獲取上下文物件OgnlContext
OgnlContext context = new OgnlContext(); // 它就是一個java.util.Map
// 2.操作
Object value = Ognl.getValue("@java.lang.Math@random()", context, context.getRoot());
Object value2 = Ognl.getValue("@java.lang.Math@PI", context, context.getRoot());
System.out.println(value);
System.out.println(value2);
複製程式碼

訪問Ognl上下文

@Test
public void test3() throws Exception {
	// 1.獲取上下文物件OgnlContext
	OgnlContext context = new OgnlContext(); // 它就是一個java.util.Map
	// 2.向上下文中儲存資料
	context.put("username", "tom");
	// 3.操作
	Object value = Ognl.getValue("#username", context, context.getRoot());
	System.out.println(value);
}

@Test
public void test4() throws Exception {
	// 1.獲取上下文物件OgnlContext
	OgnlContext context = new OgnlContext(); // 它就是一個java.util.Map
	// 2.儲存資料
	Map<String, String> map = new HashMap<String, String>();
	map.put("username", "fox");
	context.put("username", "tom");
	// 將map儲存到context的根中
	context.setRoot(map);
	// 3.操作
	Object value = Ognl.getValue("username", context, context.getRoot());
	System.out.println(value);
}
複製程式碼

如果從根中獲取資料，不需要新增#號，如果不是從根中獲取，需要#。

如果root中存了一個物件，可以直接訪問這個物件的屬性。如果是存在上下文context中的物件則需要通過”物件.屬性”的形式訪問

操作集合

// 操作集合
@Test
public void test5() throws OgnlException {
	// 1.獲取上下文物件OgnlContext
	OgnlContext context = new OgnlContext(); // 它就是一個java.util.Map
	//2.操作
	Object value = Ognl.getValue("{'hello','good','well'}", context,context.getRoot()); //相錄於建立了一個List集合
	context.setRoot(value);		
	System.out.println(Ognl.getValue("[0]",context, context.getRoot()));		
	//Object value2 = Ognl.getValue("#{'username':'tom','age':20}", context,context.getRoot()); //相當於建立了一個Map集合		
	//System.out.println(value2.getClass());
}
	
//支援表示式賦值及串聯
@Test
public void test6() throws OgnlException {
	// 1.獲取上下文物件OgnlContext
	OgnlContext context = new OgnlContext(); // 它就是一個java.util.Map		
	//2.操作		
	Object value = Ognl.getValue("#{'username':'tom','age':20}", context,context.getRoot()); //相當於建立了一個Map集合	
	context.setRoot(value);		
	Object value2 = Ognl.getValue("username='張三',age=45", context,context.getRoot());
	System.out.println(value2);				
}
複製程式碼

Strtus2框架中如何使用ognl表示式

在struts2框架中我們使用ognl表示式的作用是從valueStack中獲取資料。我們在struts2框架中可以使用ognl+valueStack達到在頁面(jsp)上來獲取相關的資料。要想在jsp頁面上使用ognl表示式，就需要結合struts2框架的標籤 <%@taglib prefix="s" uri="/struts-tags"%> <s:property value="表示式"> 來使用.

七、valueStack 值棧

valueStack介紹

我們使用valueStack的主要目的是為我將我們action中產生的資料攜帶到頁面上，也就是說valueStack它就是一個容器。

在Struts2框架中將valueStack設計成一個介面。 com.opensymphony.xwork2.util.ValueStack

我們主要使用的是它的實現類 com.opensymphony.xwork2.ognl.OgnlValueStack。

當客戶端向我們傳送一個請求，伺服器就會創始一個Action來處理請求，struts2中的action是一個多例，每一次請求都會有一個新的action對應。所以它不存線上程安全問題。一個valueStack對應一個action，valueStack貫穿整個action的生命週期。 rquest------Action------ValueStack

struts2框架將valueStack儲存在request中。在Dispatcher.class中有以下程式碼

valueStack內部結構

valueStack主要有兩部分組成: CompoundRoot:它就是一個ArrayList 它主要儲存的是action的相關資料 Map<String,Object> context:就是一個Map Context中主要儲存了一些引用，這個引用主要是關於web開發中相關資訊 pameters :請求引數 request:請求物件中所有屬性 session:會話物件中所有屬性 application:application物件中的所有發展以上都是Map

在struts2框架中我們通過ognl表示式來獲取valueStack中資料，沒有使用#就會從CompoundRoot中獲取資料，如果使用#來獲取，這時就會從context中來獲取。

獲取ValueStack

一種方式:可以直接通過request物件來獲取

ValueStack stack = (ValueStack) ServletActionContext.getRequest().getAttribute("ServletActionContext.STRUTS_VALUESTACK_KEY");
複製程式碼

二種方式:使用ActionContext來獲取

ValueStack stack = ActionContext.getContext().getValueStack();
複製程式碼

ActionContext是什麼

ActionContext它是action上下文，strtus2框架它使用actionContext來儲存Action在執行過程中所需要的一些物件，例如 session, application…

ActionContext的獲取 是通過它的靜態方法getContext()得到。 Struts2會根據每一次的http請求來建立對應的ActionContext,它是與當前執行緒繫結的。

每一次請求，就是一個執行緒，對應著一個request,每一次請求，會建立一個Action,每一個action對應一個ActionContext.每一次請求也對應著一個valueStack. request---ActionContext----Action-----ValueStaci它們都對應著一次請求(一個執行緒). valueStack與ActionContext本質上是可以獲取

ActionContext裡存有一個valueStack的context,而valueStack的context裡存有valueStack的一個Root

valueStack操作---儲存資料

手動向valueStack儲存資料

// 向valueStack儲存資料
stack.set("name", "tom");
// 底層會建立一個HashMap，儲存資料，在將hashMap儲存到root中。
stack.push("hello word!");
// 向root中儲存
複製程式碼

Struts2框架自動向valueStack中儲存資料

每次請求，訪問action，這個物件會儲存到valueStack中。在DefaultActionInvocation的init方法內

在ModelDrivernInterceptor中會將模型物件儲存到valueStack中。

valueStack操作---獲取資料

在jsp頁面中如何從valueStack中獲取資料的問題，讓我們通過以下程式碼和執行結果來分析。

<body>
<s:property value="[0].top"/>
<br/>
<s:property value="username2"/>
<br/>
<s:property value="username"/>
<br/>
<s:property value="password"/>
<br/>
<s:property value="user.username"/>
<br/>
<s:property value="model.username"/>
<br/>
<s:property value="loginMsg"/>
<s:actionerror />
<form action="${ pageContext.request.contextPath }/LoginAction" method="post">
	賬號：<input type="text" name="username"><br/>
	密碼：<input type="password" name="password"><br/>
	<input type="submit" value="LOGIN">
</form>
<s:debug/>
</body>
複製程式碼

輸入使用者名稱和密碼：tom：111

public class LoginAction extends ActionSupport implements ModelDriven<User>{
	private String username2 = "rose";
	public String getUsername2(){
		return "Rose";
	}
	private User user = new User();
	public User getModel() {
		return user;
	}
	public User getUser() {
		return user;
	}
	public String login(){	
		 if("tom".equals(user.getUsername())&&"123".equals(user.getPassword())){
			 System.out.println(user);
			 ServletActionContext.getRequest().getSession().setAttribute("user", user);
			 return "success";
		 }else{
			 ActionContext actionContext = ActionContext.getContext();
			 ValueStack valueStack = actionContext.getValueStack();
			 user = new User();
			 user.setUsername("fox");
			 user.setPassword("456");
			 valueStack.set("username","jack");
			 valueStack.set("loginMsg","使用者名稱或密碼錯誤！");
			 valueStack.push("hello word!");
			 return "failer";
		 }	 
	}	

public class User {
	private String username;
	private String password;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	@Override
	public String toString() {
		return "User [username=" + username + ", password=" + password + "]";
	}
}
複製程式碼

結果圖如下

分析結論：

com.lbb.struts2.action.LoginAction代表Action本身
com.lbb.struts2.domain.User代表的是最初始的接受的model例項物件，而LoginAction中的model和user代表的是LoginAction類中user屬性這個引用。如果在類的方法中user屬性沒有被重新賦值，那麼他們指向同一個例項物件，如果user屬性被重新賦值，則com.lbb.struts2.domain.User仍指向最初的model物件，而LoginAction中的model和user則指向新的例項物件。從com.lbb.struts2.domain.User中取屬性直接寫屬性名就行，參考第四行結果，如果要從com.lbb.struts2.action.LoginAction的物件中取屬性，要寫上物件名，參考第五行，第六行結果。可以參考下圖進行理解
com.lbb.struts2.domain.User以上的資料就是我們手動向新增valueStack中新增的資料
從valueStack中取資料的順序是從上向下取第一個找到的對應的元素。例如手動設定的和com.lbb.struts2.domain.User中都有的時候，取手動存的。沒有手動存的時候取com.lbb.struts2.domain.User中的。參考第三行和第四行的資料。

El表示式可以從valueStack中獲取資訊

為什麼el表示式可以從valueStack中獲取資料？ 在org.apache.struts2.dispatcher.StrutsRequestWrapper中

Struts2框架對request進行了增強，重寫了getAttribute方法，如果在request域中查詢不到資料，就會在valueStack中獲取。

Ognl表示式中特殊字元

OGNL是通常要結合Struts 2的標誌一起使用。主要是#、%和$這三個符號的使用

#號:它是從非root中獲取資料 %用於強制是否要解析ognl表示式

<%
		request.setAttribute("username", "tom");
		session.setAttribute("password", "123");
	%>
	<h1>#號用法</h1>
	<s:property value="#request.username" />
	<br>
	<s:property value="#session.password" />
	<br>
	<!-- localhost:8080/struts2-day02/ognl3.jsp?username=tom -->
	<s:property value="#parameters.username"/>
	
	<h2>%號用法</h2>
	<s:property value="%{#request.itcast}"/><br> <!-- 會解析成ognl -->
	<s:property value="%{'#request.itcast'}"/><br> <!-- 不會解析ognl -->
	
	<s:debug />
複製程式碼

$它主要是在配置檔案中來獲取valueStack中資料

<action name="vs" class="com.lbb.action.ValueStackAction">	
	<result name="success" type="redirect">/ognl2.jsp?username=${model.username}</result>
</action>
複製程式碼

八、Interceptor攔截器

Interceptor攔截器

Struts2中的interceptor它是基於spring aop思想，而aop思想它本質上是通過動態代理來實現。我們strtus2的攔截器它主要是攔截Action的操作，在action的執行前或執行後進行一些其它的功能操作。

以下是struts2的執行流程圖

執行的過程 當我們傳送請求訪問Action時，會被StrutsPrepareAndExecuteFilter攔截在其doFilter方法內執行了 execute.executeAction(request, response, mapping)。

這個程式碼執行後,dispatcher.serviceAction(request, response, mapping)， serviceAction方法執行。

在這個方法執行過程中會建立Action代理物件

ActionProxy proxy = getContainer().getInstance(ActionProxyFactory.class).createActionProxy(namespace, name, method, extraContext, true, false);
複製程式碼

通過proxy去執行了proxy.execute()，在execute方法內return invocation.invoke()。

invocation它是ActionInvocation一個物件。在invoke方法內

會去載入我們的配置檔案，將配置檔案中所有的interceptor得到進行遍歷。在struts-default.xml檔案中定義了預設載入的攔截器棧 defaultStack

在每一個攔截器的interceptor方法內，又呼叫了DefaultActionInvocation的invoke方法，其實就是遞迴呼叫。

Interceptor作用與自定義Interceptor

我們使用intercep[tor可以在action執行前後進行處理工作。例如，完成許可權控制。

問題：如何定義Interceptor

所有的Interceptor都要實現一個介面 com.opensymphony.xwork2.interceptor.Interceptor

在配置檔案中宣告Interceptor

我們也可以將多個interceptor封裝成一個stack

可以在Action的配置中引入自己的interceptor 在使用時name也可以引入一個interceptor stack.

注意:當我們顯示的引入了一個自定義的Interceptor,那麼預設的defaultStack就不會在匯入，需要手動匯入

<!-- 宣告 -->
<interceptors>
	<interceptor name="myInterceptor" class="cn.lbb.utils.MyInterceptor">
	<param name="includeMethods">showProduct</param>
	<param name="excludeMethods">addProduct</param>
	</interceptor>
		<interceptor-stack name="myStack">
			<interceptor-ref name="myInterceptor"/>
			<interceptor-ref name="defaultStack"></interceptor-ref>	
		</interceptor-stack>
</interceptors>	

<action name="product_*" class="cn.lbb.action.ProductAction" method="{1}">
	<result name="success">/product.jsp</result>
	<result name="login">/login.jsp</result>
	<interceptor-ref name="myStack"/>			
</action>
複製程式碼

我們在struts.xml檔案中配置action時，可以使用*通配置符，這時它可以處理多個方法，你指定的interceptor只想攔截某一個方法，可以使用Interceptor介面的一個實現類來完成操作MethodFilterInterceptor。

小結

注意：在實際開發中，我們一般會讓action去繼承ActionSupport類，這樣可以使用父類提供的對於錯誤操作的處理this.addActionError("錯誤資訊！") 在struts2中處理簡單的資訊(字串)

this.addActionError("錯誤資訊！")
this.addFieldError(fieldName,errorMessage)
this.addActionMessage(amessage)
複製程式碼

第一個：一般用於邏輯業務操作第二個：對接收的引數進行格式校驗，是否滿足格式第三個：普通訊息獲取

<s:actionerror/>
<s:fielderror/>
<s:actiommessage/>
複製程式碼

要想在頁面上展示集合資訊可以使用<s:iterator>標籤來完成

<s:iterator value="ps">
	<tr>
		<td><s:property value="name" /></td>
		<td><s:property value="price" /></td>
		<td><s:property value="count" /></td>
	</tr>
</s:iterator>

<s:iterator value="ps" var="p">
	<tr>
		<td><s:property value="p.name" /></td>
		<td><s:property value="p.price" /></td>
		<td><s:property value="p.count" /></td>
	</tr>
</s:iterator>
複製程式碼

九、Struts2檔案上傳

瀏覽器端注意事項

表單提交方式method=post 表單中必須有一個元件表單中必須設定enctype=”multipart/form-data”

伺服器端

Commons-fileupoad.jar包完成。

Struts2框架使用一個fileupload的interceptor來完成檔案上傳

上傳案例

<form action="${ pageContext.request.contextPath }/upMany" enctype="multipart/form-data" method="post">
<input type="file" name="upload">
<input type="file" name="upload">
<input type="submit" value="上傳">
</form>
複製程式碼

public class UploadActionMany extends ActionSupport{
//	 extends ActionSupport 
	private File[] upload;
	private String[] uploadContentType;
	private String[] uploadFileName;
/*
	提供對應的set/get方法
*/
	public String upload(){
		System.out.println(3);
		String path = ServletActionContext.getServletContext().getRealPath("/upload");
		try {
			for (int i = 0; i < upload.length; i++) {
				File file = new File(path,uploadFileName[i]);
				FileUtils.copyFile(upload[i], file);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		System.out.println(4);
		return null;
	}
}
複製程式碼

注意事項

<!-- 開發模式 -->
<constant name="struts.devMode" value="true"></constant>
<!-- 設定檔案上傳的大小限制 -->
<constant name="struts.multipart.maxSize" value="40971520"></constant>
<action name="upMany" class="com.lbb.struts2.action.UploadActionMany" method="upload">
	<!-- 檔案上傳出錯後的檢視 -->
	<result name="input">/error.jsp</result>
	<interceptor-ref name="fileUpload">
		<!-- <param name="maximumSize"></param> --><!-- 設定每一個檔案的單獨的上傳大小 -->
		<!-- <param name="allowedTypes"></param> --><!-- 檔案的mime型別 -->
		<param name="allowedExtensions">txt,jpg,bmp</param><!-- 設定允許的字尾名 -->
	</interceptor-ref>
	<interceptor-ref name="defaultStack"></interceptor-ref>
</action>
複製程式碼

input接受錯誤資訊

<s:actionerror/>
<s:fielderror/>
複製程式碼

十、Struts2框架使用Ajax的方式

使用HttpServletResponse響應資料

在struts2框架中可以獲取HttpServletResponse物件，就可以通過response來完成將資料(json)響應到瀏覽器過程。

使用strtus2框架的json外掛來完成ajax操作

首先要匯入外掛包struts2-json-plugin-2.3.24.jar

我們怎樣使用struts2提供的json外掛

將我們自己配置檔案中的<package extends=”json-default”>.
Action的返回檢視<result name=”” type=”json”>
因為我們配置了上面兩步，那麼struts2框架就會將valueStack中的棧頂元素轉換成json響應到瀏覽器

案例

<script type="text/javascript">
$(function(){
	$("#productaa").toggle(function(){
		$.post("/day03_struts2/struts2_ajax/showProduct",{},function(data){
			$("#product").append("<tr><td>商品名</td><td>價格</td></tr>")
			$.each(data,function(i,n){
				$("#product").append("<tr><td>"+n.name+"</td><td>"+n.price+"</td></tr>")
			});
		},"json");
	},function(){
		$("#product").html("");
	});
});
</script>
<body>
<a href="javascript:void(0)" id="productaa">檢視商品</a>
<div>
<table id="product" border="1"></table>
</div>
</body>
複製程式碼

<package name="default3" namespace="/struts2_ajax" extends="json-default">
		
		<action name="showProduct" class="com.lbb.struts2.action.ProductAction" method="show">
			<result name="success" type="json">
				<!-- 設定生成資料時的根 -->
				<!-- 
					沒有設定root前返回的json結構   ps:[{},{}]
					設定root它的根為ps後的返回的json結構  [{},{}]
				 -->
				<param name="root">list</param>
				<!-- 生成json資料時包含或不包含屬性 -->
				<param name="excludeProperties">\[\d+\]\.releaseDate</param>
				<!-- <param name="includeProperties">ps\[\d+\]\.id,ps\[\d+\]\.name</param> -->
			</result>
		</action>
		
	</package>
複製程式碼

public String show(){
		List<Product> list = new ArrayList<Product>();
		/*
		......
		*/
		list.add(product1);
		list.add(product2);
		list.add(product3);
		ActionContext.getContext().getValueStack().set("list",list);
		return "success";
	}
複製程式碼

public class Product {
	private int id;
	private String name;
	private double price;
	private Date releaseDate;
//	@JSON(serialize=false)	生成json資料時忽略屬性
	public Date getReleaseDate() {
		return releaseDate;
	}
	/*
	對應的set/get方法
	*/	
}
複製程式碼

十一、Struts2註解開發

想使用struts2的註解，我們必須單獨在匯入一個jar包。它是在strtus2的2.1版本後引入。struts2-convention-plugin-2.3.24.jar

我們在action類中定義了註解，strtus2框架怎樣識別它們 我們必須檢視外掛包中的配置,會發現 <constant name="struts.convention.package.locators" value="action,actions,struts,struts2"/> 是在action,actions,struts,struts2這樣的包下掃描註解

快速入門

案例登入頁面

<body>
<s:actionerror/>
<form action="${ pageContext.request.contextPath }/user/login" method="post">
使用者名稱<input type="text" name="username"><br/>
密碼<input type="password" name="password"><br/>
<input type="submit" value="登入">
</form>
</body>
複製程式碼

登入Action

@Namespace("/user")
@ParentPackage("struts-default")
public class UserAction extends ActionSupport implements ModelDriven<User>{
	private User user = new User();
	@Override
	public User getModel() {
		return user;
	}
	@Action(value="login",results = { @Result(name="success",type="redirect",location="/product2.jsp"),
			@Result(name="error",location="/login.jsp") })
	public String login(){
		IUserService userService = new UserServiceImpl();
		try {
			user = userService.login(user);
			if(user!=null){
				ServletActionContext.getRequest().getSession().setAttribute("user",user);
				return SUCCESS;
			}else{
				addActionError("使用者名稱或密碼錯誤！");
				return ERROR;
			}
		} catch (SQLException e) {
			e.printStackTrace();
			throw new RuntimeException();
		}
	}
}
複製程式碼

商品展示頁面

<script type="text/javascript" src="/day04_struts2_exam/js/jquery-1.8.3.js"></script>
<body>
<script type="text/javascript">
$(function(){
	$("#productaa").toggle(function(){
		$.post("${pageContext.request.contextPath}/product/productlist",{},function(data){
			if(data.type=="1"){
				$("#product").append("<tr><td>商品名</td><td>價格</td></tr>")
				$.each(data.list,function(i,n){
					$("#product").append("<tr><td>"+n.name+"</td><td>"+n.price+"</td></tr>")
				});
			}else{
				alert(data.message);
			}
		},"json");
	},function(){
		$("#product").html("");
	});
});
</script>
<a href="javascript:void(0)" id="productaa">檢視商品</a>
<div>
<table id="product" border="1"></table>
</div>
</body>
複製程式碼

定義一個被商品Action繼承的包，宣告許可權控制攔截器

<package name="base" namespace="/" extends="struts-default">
		<interceptors>
			<interceptor name="myInterceptor" class="com.lbb.struts2.interceptor.MyInterceptor">
			</interceptor>
			<interceptor-stack name="myStack">
				<interceptor-ref name="myInterceptor"></interceptor-ref>
				<interceptor-ref name="defaultStack"></interceptor-ref>
			</interceptor-stack>
		</interceptors>
	</package>
複製程式碼

商品展示Action

@Namespace("/product")
@ParentPackage("base")
public class ProductListAction {
     @Action(value="productlist",interceptorRefs={@InterceptorRef("myStack")})
	public void showProduct2(){
		ServletActionContext.getResponse().setContentType("text/html;charset=UTF-8");
		IProductService productService = new ProductServiceImpl();
		try {
			Result<Product> result = new Result<>();
			result.setType(1);
			List<Product> list = productService.findAll();
			result.setList(list);
			String resultString = JSONObject.toJSONString(result);
			System.out.println(resultString);
			ServletActionContext.getResponse().getWriter().println(resultString);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
複製程式碼

許可權控制攔截器

public class MyInterceptor extends MethodFilterInterceptor{
	@Override
	protected String doIntercept(ActionInvocation arg0) throws Exception {
		ServletActionContext.getResponse().setContentType("text/html;charset=UTF-8");
		User user = (User) ServletActionContext.getRequest().getSession().getAttribute("user");
		if(user!=null){
			return arg0.invoke();
		}else{
			Result<Product> result = new Result<>();
			result.setMessage("許可權不足！");
			String resultString = JSONObject.toJSONString(result);
			ServletActionContext.getResponse().getWriter().println(resultString);
			return null;
		}
	}
}
複製程式碼

其他註解

@Actions 用在方法上

@Actions({
    @Action(value = "testAction",results = {@Result(location="/success.jsp")}),
    @Action(value = "testAction2",results = {@Result(location="/success.jsp")})
})
public String demo1(){
	......
}
複製程式碼

@Results 用在類上，相當於全域性結果檢視

@Results( { @Result(name = "global", location = "/global.jsp") })  
public class demo1 extends ActionSupport {  
  
    @Action(value = "test1", results = { @Result(name = "success", location = "/success.jsp"),  
            @Result(name = "failure", location = "/fail.jsp") })  
    public String execute() {  
        if (...) {  
            return "failure";  
        } else if (...) {  
            return "success";  
        } else {  
            return "global";  
        }  
    }  
  
    @Action("test2")  
    public String demo2() {  
        return "global";  
    }  
}  
複製程式碼

spring框架快速入門筆記
2018-04-14
Spring框架筆記
Swift快速入門筆記
2017-03-17
Swift筆記
Hibernate快速入門筆記
2018-04-09
筆記
ReactNative快速入門筆記
2017-09-19
React筆記
Docker快速入門總結筆記
2022-03-12
Docker筆記
HTML基礎快速入門筆記
2021-01-02
HTML筆記
【整理】ReactNative快速入門筆記
2017-06-19
React筆記
CI 框架簡單入門筆記
2019-02-16
框架筆記
Thinkphp5.0快速入門筆記（1）
2019-08-02
PHP筆記
【MongoDB學習筆記】MongoDB 快速入門
2021-12-21
MongoDB筆記
JavaScript學習筆記1—快速入門
2018-11-02
JavaScript筆記
Go語言快速入門筆記01
2021-11-29
Go筆記
substrate學習筆記2：substrate快速入門
2022-03-21
筆記
flask文件學習筆記1-快速入門
2019-02-16
Flask筆記
MyBatis 框架之快速入門程式
2019-02-18
MyBatis框架
struts2入門
2017-05-16
【筆記】PyTorch快速入門：基礎部分合集
2022-04-30
筆記PyTorch
Util應用框架快速入門(5) - 許可權入門
2023-10-28
框架
ClickHouse入門筆記
2021-08-03
筆記
vue入門筆記
2018-10-17
Vue筆記
GO入門筆記
2018-10-31
Go筆記
Docker 入門筆記
2018-02-07
Docker筆記
spark入門筆記
2018-01-22
Spark筆記
Redis入門筆記
2018-07-05
Redis筆記
NPM入門筆記
2017-01-20
NPM筆記
任務排程框架Quartz快速入門！
2020-12-26
框架quartz
struts2筆記（一）
2017-07-15
筆記
yidajiabei 的演算法筆記系列—— C / C + + 快速入門
2020-04-16
演算法筆記
【PHP】英文部落格專欄PHP快速入門個人筆記
2023-01-27
PHP筆記
Struts2基礎入門
2014-01-13
linux入門筆記
2019-03-14
Linux筆記
Python入門筆記
2019-03-10
Python筆記
Python 入門筆記
2019-07-16
Python筆記
selenium 入門筆記
2018-10-09
筆記
ByteBuddy入門筆記
2023-04-27
筆記
Haskell 入門筆記(四)
2016-10-09
Haskell筆記
JavaScript入門筆記（2）
2017-08-06
JavaScript筆記
【安卓筆記】ormlite入門
2015-06-02
安卓筆記ORM