尚学堂-马士兵Struts2教学视频之Struts2 学习笔记

Struts2 学习笔记
---wjt276 [二○一○年一月五日完]
目录
01 Struts2-Action (5)
一、Struts作用： (5)
二、搭建Struts2的运行环境： (5)
三、Namespace (6)
四、<package>标签 (6)
五、Action (6)
六、路径问题的说明 (8)
七、Action的动态调用方法 (8)
八、Action通配符(wildcard)的配置 (9)
九、Action的属性接收参数 (10)
1、在Action添加成员属性接受参数 (10)
2、域模型(Domain Model) (10)
3、ModelDriven接收参数 (11)
十、Action属性接收参数中文问题 (12)
十一、简单数据验证 (12)
十二、访问Web元素 (14)
一、方法一：ActionContext方式 (15)
二、方式二：Ioc(控制反转)—推荐使用 (15)
三、方式三：获取原类型 (16)
四、方式四：获取原类型-控制反转 (17)
十三、Struts2配置文件模块化包含(include) (17)
十四、默认的Action (18)
十五、Action总结 (18)
02 Struts2-Result (19)
一、Result类型 (type) (19)
二、全局结果集(Globle Result) (20)
三、动态的结果集(dynamic result) (21)
四、带参数的结果集 (21)
五、Result总结 (22)
六、项目经理： (22)
03 OGNL表达式语言 (23)
04 Struts2-Tags (28)
Struts2标签目录 (28)
一、property标签 (28)
二、set标签 (29)
三、bean标签 (29)
四、<include>标签－少使用 (29)
五、If elseif else (30)
六、Iterator标签 (31)
七、Theme (31)
05设计约定(编码规定) (32)
06 项目开发顺序 (32)
07 声明式异常处理 (33)
08 国际化 (35)
一、国际化资源文件 (35)
二、Java国际化 (35)
Struts学习笔记第3页共39页
三、Struts2国际化 (35)
1、Action级别 (35)
2、Package级别 (36)
3、Application级别 (36)
四、资源文件中的参数处理 (37)
五、国际化-动态语言切换 (37)
09 自定义拦截器 (38)
10 类型转换 (38)
Struts2总结 (39)
目录
Action
⏹简单数据校验
Result
常用配置文件
OGNL & ValueStack
Tags
---------------------Project
⏹类型转换、上传与下载、interceptor、防止重复提交 MVC思想深入剖析
源码解读
其他话题
01 Struts2-Action
一、Struts作用：
将请求与结果分开
二、搭建Struts2的运行环境：
1、建立Web项目；
2、建立Struts2的配置文件(struts.xml)；
将Struts2的空项目中的配置文件(struts.xml)复制到项目的src目录下。

配置如下：
<!--
struts.devMode :是否设置为开发模式true:是开发模式，否则不是
注：在开发模式下，修改Struts的配置文件后不需要重新启动Tomcat服务器即生效。

否则修改Struts配置文件后需要重新启动Tomcat服务器才生效。

-->
<constant name="struts.devMode"value="true"/>
<!--
namespace :对应与项目名称后面的"/"(例如Struts2_0100_Introduction后面的"/") (http://localhost:8080/Struts2_0100_Introduction/)
-->
<package name="default"namespace="/"extends="struts-default">
<action name="hello">
<result>
/hello.jsp
</result>
</action>
</package>
3、复制Struts2相应的jar包及第三方包。

将空项目中lib目录中的除junit和spring-test之外的所有文件复制到项目的WebRoot/WEB-INF/lib目录下
4、修改对应的web.xml，建立struts2的filter（参考struts自带的项目），添加如下配置：
<filter>
<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>
三、Namespace
Namespace决定了action的访问路径，默认为“”，可以接收所有路径的action，如果没有找到相应的namespace时，则使用namespace为空的action
Namespace可以写为/，或者/xxx,或者/xxx/yyy，对应的action访问路径为/index.action、/xxx/index.action、或者/xxx/yyy/index.action.
Namespace最好也用模块来进行命名。

namespace :对应与项目名称后面的"/"(例如Struts2_0100_Introduction后面的"/")
(http://localhost:8080/Struts2_0100_Introduction/)
四、<package>标签
<package>是用来解决重名的问题，例如当系统的前台和后台都有一个action名叫hello，这时就需要用package来区分。

前台<package name="front">后台<package name="back">
struts2中的package与java的package是相同的作用的。

五、Action
具体视图的返回可以由用户自己定义的Action来决定
具体的手段是根据返回的字符串找到对应的配置项，来决定视图的内容，有三种手段：
<constant name="struts.devMode"value="true"/>
<package name="front"extends="struts-default"namespace="/">
<action name="index"class="com.bjsxt.struts2.front.action.IndexAction1"> <result name="success">/ActionIntroduction.jsp</result>
</action>
</package>
注：<action>标签中的class属性是表示action的对应的类(这个类是一个普通Java类)，当访问这个action时会创建这个类成为一个对象，然后执行这个对象中的execute方法()(execute方法返回类型为String)。

第一种:Action 普通Java类
public class IndexAction1 {
public String execute() {
return"success";
}
}
当<action>标签中class属性省略时，则默认执行com.opensymphony.xwork2.ActionSupport类中的execute方法,而这个方法返回一个字符串常量SUCCESS(常量值为：”success”).
第二种:Action 实现com.opensymphony.xwork2.Action接口，这个接口中定义了一些常量和一个execute 方法，我们重写execute()方法就可以了。

import com.opensymphony.xwork2.Action;
public class IndexAction2 implements Action {
@Override
public String execute() {
//return "success";
return this.SUCCESS;//SUCCESS常量值为："success"
}
}
第三种:Action 继承com.opensymphony.xwork2.ActionSupport类，而这个类又实现了
com.opensymphony.xwork2.Action接口，我们重写execute()方法就可以了。

import com.opensymphony.xwork2.ActionSupport;
public class IndexAction3 extends ActionSupport {
@Override
public String execute() {
//return "success";
return this.SUCCESS;//SUCCESS常量值为："success"
}
}
注：第三种Action是我们需要使用的方式，因为这个类不担实现了com.opensymphony.xwork2.Action 接口，更重要的是它已经帮我封装了许多其它有用的方法。

六、路径问题的说明
struts2中的路径问题是根据action的路径而不是jsp路径来确定，所以尽量不要使用相对路径。

虽然可以用redirect方式解决，但redirect方式并非必要。

解决办法非常简单，统一使用绝对路径。

（在jsp中用request.getContextRoot方式来拿到webapp的路径）或者使用myeclipse经常用的，指定basePath
还有另一种方式，就是在<head>标签中，指定<base>标签值，这样就使用统一绝对路径。

<%
String path = request.getContextPath();//
String basePath =
request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+ "/";
%>
<head>
<base href="<%=basePath%>" />
…………
注：<base>标签：当前页面中所有连接都会在前面加上base地址。

七、Action的动态调用方法
Action执行的时候并不一定要执行execute方法，我们可以指定Action执行哪个方法：
1、方法一(通过methed属性指定执行方法)：
可以在配置文件中配置Action的时候用method=来指定执行哪个方法
<action name="userAdd"class="erAction"method="add"> <result>/user_add_success.jsp</result>
</action>
这样，只要在action的对象中有一个add的方法，并且返回类型为String就可以了。

如果没有method属性，则默认执行execute()方法。

import com.opensymphony.xwork2.ActionSupport;
public class UserAction extends ActionSupport {
public String add() {
return SUCCESS;
}
}
2、动态方法调用DMI(推荐)
可以在url地址中动态指定action执行那个方法。

Url地址如下：
http://localhost:8080/Struts2_0500_ActionMethod/user/user!add
方法：action + ! + 方法名
注：只要Action对象中有这个方法，并且返回类型为String就可以调用。

这样Struts.xml配置文件中不需要配置methed属性。

代码如下：
<action name="user"class="erAction"> <result>/user_add_success.jsp</result>
</action>
Action类：
public class UserAction extends ActionSupport {
public String add() {
return SUCCESS;
}
}
总结：推荐使用第二种动态方法调用DMI，因为第一种需要大量的Action配置，后者可以在url中动态指定执行action中哪个方法。

八、Action通配符(wildcard)的配置
使用通配符，将配置量降到最低, 不过，一定要遵守"约定优于配置"的原则
1、通配符
星号(*) 表示所有
{数字}表示第几个通配符
例如：Student* 那么{1}代表第一个星号(*)
*_* 那么{1}代表第一个星号(*) ，{2}代表第二个星号(*)
2、实例
<package name="actions"extends="struts-default"namespace="/actions"> <action name="Student*"class="com.bjsxt.struts2.action.StudentAction"
method="{1}">
<result>/Student{1}_success.jsp</result>
</action>
<action name="*_*"class="com.bjsxt.struts2.action.{1}Action"method="{2}"> <result>/{1}_{2}_success.jsp</result>
<!-- {0}_success.jsp -->
</action>
</package>
解释：第一个Action的名称为name=”Student*”method=”{1}”,表示所有Action以Student开始的都会执行这个Action,并且执行Student后字符为方法名的方法，例如：访问的Action为Studentadd，会执行这个Action(Student*)，并且执行add的方法.因为{1}在这里代表add,并且返回/Studentadd_success.jsp 页面。

第二个Action的名称name=”*_*”method=”{2}”class=”…action.{1}Action”表示所有Action 中包含下划线(“_”)都会执行这个Action,例如：Teacher_add,那么会执行这个Action,并且Action对应的类为TeacherAction,且执行Action中的add方法，返回结果页面为/Teacher_add_success.jsp，因为在这里的{1}表示Teacher,{2}表示add
3、匹配顺序
当匹配的Action有两个以上时，则会按匹配精确度高的那个Action，当有个相同的匹配精确度时，则按先后顺序进行。

九、Action的属性接收参数
Action中三种传递并接受参数：
1、在Action添加成员属性接受参数
例如请求的URL地址：
http://localhost:8080/Struts2_0700_ActionAttrParamInput/user/user!add?name=a&age=8
其中传递了两个参数：name和age,其值分别为：a、8，此Action执行的是add()方法。

那我们只要在user这个Action对象中添加这两个成员属性并生成set、get方法。

public class UserAction extends ActionSupport {
private String name;
private int age;
public String add() {
System.out.println("name=" + name);
System.out.println("age=" + age);
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
= name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
2、域模型(Domain Model)
就是利用对象域来进行传递和接受参数
例如请求的URL地址：
http://localhost:8080/Struts2_0800_DomainModelParamInput/user/user!add?=a &user.age=8
其中，访问的是namespace=”/user” action的name=”user” Action所执行的方法method=”add”
利用对象域user来传递参数,为对象的属性赋值(=a user.age=8)
注：需要一个对象user并且这个对象需要有两个成员属性，且具有get、set方法。

然后在Action中添加一个User对象的成员属性。

并且有get、set方法，就可以了。

//User对象
public class User {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
= name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
//Action类
public class UserAction extends ActionSupport {
private User user;
//private UserDTO userDTO;
public String add() {
System.out.println("name=" + user.getName());
System.out.println("age=" + user.getAge());
return SUCCESS;
}
public User getUser() {
return user;
}
public void setUser(User user) {
er = user;
}
}
3、ModelDriven接收参数
使Action实现com.opensymphony.xwork2.ModelDriven<User>(在实现接口时需要使用泛型，否则使用时需要转型)中利用其getModel()方法返回对象模型，从而获得传入的参数。

例如URL如下：
http://localhost:8080/Struts2_0900_ModelDrivenParamInput/user/user!add?name=a &age=8
其：访问的是namespace=”/user” action的name=”user” Action所执行的方法method=”add”，其传入了两个参数：name=a,age=8。

参数被传入至Action后，会被ModelDriven对象根据参数名自动赋值给User对象相应的属性而生成User对象，并且由getModel()返回。

那么我们在Action中就可以利用这个对象了。

注意：传入的参数名需要与对象模型中的成员属性一致。

对象模型User:
public class User {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
= name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
Action对象
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.ModelDriven;
public class UserAction extends ActionSupport implements ModelDriven<User>{ private User user = new User();
public String add() {
System.out.println("name=" + user.getName());
System.out.println("age=" + user.getAge());
return SUCCESS;
}
@Override
public User getModel() {
return user;
} }
十、Action属性接收参数中文问题
如果表单提交数据中有中文时，尽量使用post方式。

需要在Struts.xml配置文件中加入一个常量配置，如下：
<struts>
<constant name="struts.devMode"value="true"/>
<constant name="struts.i18n.encoding" value="GBK" /><!-- internationalization --> <package name="user"extends="struts-default"namespace="/user">
<action name="userAdd"class="erAction"
method="add">
<result>/user_add_success.jsp</result>
</action>
</package>
</struts>
但是，在Struts2 2.7之前，这个配置无效，需要其它方法设置。

如下：
手动在web.xml中在Struts过滤器之前配置一个过滤器用于解决中文的问题。

十一、简单数据验证
使用addFieldError方法和s:fieldError标签简单处理数据校验
场景：对一个用户名进行验证，如果用户名不合法，则显示给客户端查看信息。

URL请求地址：
http://localhost:8080/Struts2_1100_SimpleDataValiation/user/user!add?name=a
分析：访问的Struts2配置,namespace=”/user” action的name=”user” Action所执行的方法method=”add”并且传入了一个参数name=a.如下：
<package name="user"extends="struts-default"namespace="/user">
<action name="user"class="erAction"> <result>/user_add_success.jsp</result>
<result name="error">/user_add_error.jsp</result>
</action>
</package>
根据配置文件可以得知action所对应的类为erAction,并且具有两个结果集(success和error).代码如下：
import com.opensymphony.xwork2.ActionSupport;
public class UserAction extends ActionSupport {
private String name;
public String add() {
if(name == null || !name.equals("admin")) {
//addFieldError 添加错误信息，可以在客户端访问到。

this.addFieldError("name", "name is error");
this.addFieldError("name", "name is too long");
return ERROR;
}
return SUCCESS;
}
public String getName() {
return name;
}
public void setName(String name) {
= name;
}
}
根据Action类代码，可以看到Action是利用Action的成员属性(name)来接受参数值，并且使用this.addFieldError()方法添加错误信息，以便前台可以访问到。

this.addFieldError(name, errorMessage);
注：此方法是使用继承了ActionSupport父类的
name:可以是傻的属性名称，但一般建议使用哪个成员属性出题了，就用那个。

当前是因为name没有通过验证，所以使用name errorMessage:添加的信息
在客户端获取这些信息，如下：
<body>
User Add Error!
<s:fielderror fieldName="name"theme="simple"/>
<br/>
<s:property value=""/>
<s:debug></s:debug>
</body>
注：使用<s:fielderror>标题，需要使用<%@taglib>命令引用Struts2的标签库如下：
<%@taglib uri="/struts-tags"prefix="s"%>
1、<s:fielderror>标签：获取使用addFieldError()方法添加的信息。

FiledName：指定信息的名称。

Theme: 指定显示的主题。

注：使用此标签获取的错误信息，Struts强制添加了css的修饰。

生成的HTML代码如下(不长用)：
<ul class="errorMessage">
<li><span>name is error</span></li>
<li><span>name is too long</span></li>
</ul>
Class=”errorMessage”是Struts2已经设置好的一个css了。

这个方式不方便我们自定义样式。

2、<s:debug></s:debug>：这是标签的写方式，会在页面上产生一个链接，点击后显示如下(Struts2生成的一些信息)：
3、<s:property>标签：获取值堆栈属性所对应的值。

<s:property value=""/>
注：value:指定值堆栈的属性名及数据下标等。

例如：value=”a”获取Action类的成员属性a的值
Value=”errors”获取errors属性的对象Map值
Value=””获取errors属性的对象Map的key为name的value
Value=”[0] 获取errors属性的对象Map的key为name的value的第一个元素的值。

注：如果获取Action Context中的Key值，需要在前面加#(井号)
例如：<s:property value=”#request”/>
十二、访问Web元素
取得Map类型request,session,application,真实类型 HttpServletRequest, HttpSession, ServletContext的引用:
1.前三者：依赖于容器
2.前三者：IOC (只用这种)
3.后三者：依赖于容器
4.后三者：IOC
一、方法一：ActionContext方式
一般在Action类的构造方法、或execute()方法中获取。

public class LoginAction1 extends ActionSupport {
private Map request;
private Map session;
private Map application;
public LoginAction1() {
request = (Map)ActionContext.getContext().get("request");
session = ActionContext.getContext().getSession();
application = ActionContext.getContext().getApplication();
}
public String execute() {
request.put("r1", "r1");
session.put("s1", "s1");
application.put("a1", "a1");
return SUCCESS;
}
}
然后在Jsp页面中获取相关web元素。

<body>
User Login Success!
<br/>
<s:property value="#request.r1"/> | <%=request.getAttribute("r1") %><br/>
<s:property value="#session.s1"/> | <%=session.getAttribute("s1") %><br/>
<s:property value="#application.a1"/>| <%=application.getAttribute("a1") %><br/> <s:property value="#attr.a1"/><br/>
<s:property value="#attr.s1"/><br/>
<s:property value="#attr.r1"/><br/>
<s:debug></s:debug>
<br/>
</body>
注：因为request、session、application对象Struts2将在放入到Action Context中，因此需要使用#key来访问对象们。

后面的是java脚本代码的访问方式。

二、方式二：Ioc(控制反转)—推荐使用
让Action类实现RequestAware、SessionAware、ApplicationAware接口，然后重写他们的set方法(setRequest、setSession、setApplication)，通过依赖注入、控制反转(原来自己控制，现在由别人来控制值。

)
import org.apache.struts2.interceptor.ApplicationAware;
import org.apache.struts2.interceptor.RequestAware;
import org.apache.struts2.interceptor.SessionAware;
import com.opensymphony.xwork2.ActionSupport;
public class LoginAction2 extends ActionSupport implements RequestAware,SessionAware, ApplicationAware {
private Map<String, Object> request;
private Map<String, Object> session;
private Map<String, Object> application;
//DI dependency injection依赖注入
//IoC inverse of control控制反转
public String execute() {
request.put("r1", "r1");
session.put("s1", "s1");
application.put("a1", "a1");
return SUCCESS;
}
@Override
public void setRequest(Map<String, Object> request) {
this.request = request;
}
@Override
public void setSession(Map<String, Object> session) {
this.session = session;
}
@Override
public void setApplication(Map<String, Object> application) {
this.application = application;
}
}
在视图(JSP)页面中获取相关对象，同方式一。

三、方式三：获取原类型
获取是的HttpServletRequest/HttpSession/ServletContext
public class LoginAction3 extends ActionSupport {
private HttpServletRequest request;
private HttpSession session;
private ServletContext application;
public LoginAction3() {
request = ServletActionContext.getRequest();
session = request.getSession();
application = session.getServletContext();
}
public String execute() {
request.setAttribute("r1", "r1");
session.setAttribute("s1", "s1");
application.setAttribute("a1", "a1");
return SUCCESS;
}
}
四、方式四：获取原类型-控制反转
首先需要Action实现org.apache.struts2.interceptor.ServletRequestAware接口，然后重写setServletRequest()方法，获取HttpServletRequest对象，再通过HttpServletRequest对象取昨HttpSession和ServletContext对象。

import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.apache.struts2.interceptor.ServletRequestAware;
import com.opensymphony.xwork2.ActionSupport;
public class LoginAction4 extends ActionSupport implements ServletRequestAware { private HttpServletRequest request;
private HttpSession session;
private ServletContext application;
public String execute() {
request.setAttribute("r1", "r1");
session.setAttribute("s1", "s1");
application.setAttribute("a1", "a1");
return SUCCESS;
}
@Override
public void setServletRequest(HttpServletRequest request) {
this.request = request;
this.session = request.getSession();
this.application = session.getServletContext();
}
}
十三、Struts2配置文件模块化包含(include)
<include>标签
当Struts配置文件比较多，需要模块化划分或分开成为多个配置文件时，这个功能比较好。

则需要使用<include>标签把其它的配置文件引入到Struts.xml配置文件中就可以了。

例如：有一个login.xml配置文件如下：
<?xml version="1.0"encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"/dtds/struts-2.0.dtd">
<struts>
<package name="login"extends="struts-default"namespace="/login">
<action name="login*"
class="er.action.LoginAction{1}">
<result>/user_login_success.jsp</result>
</action>
</package>
</struts>
则需要在struts.xml文件中使用<include>标签将其引入就可以了。

Struts.xml如下
<?xml version="1.0"encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"/dtds/struts-2.0.dtd">
<struts>
<constant name="struts.devMode"value="true"/>
<include file="login.xml" />
</struts>
十四、默认的Action
当用户访问的namespace下一个不存在的Action，则会将使用默认的Action。

使用<default-action-ref name=”name”>标签其中name属性指向下面已经定义的Action名称了。

<struts>
<constant name="struts.devMode"value="true"/>
<package name="default"namespace="/"extends="struts-default">
<default-action-ref name="index"></default-action-ref>
<action name="index">
<result>/default.jsp</result>
</action>
</package>
</struts>
当前访问namespace=”/”下不存在的Action时，则返回自动转到访问/default.jsp页面。

十五、Action总结
1、实现一个Action的最常用的方式：从ActionSupport继承
2、DMI动态方式的调用：！
3、通配符配置：* {1} {2}
4、接收参数的方式（一般属性或DomainModel来接收）
5、简单参数验证addFieldError
a)一般不使用Struts的UI标签
6、访问Web元素
a)Map类型
i.IoC
ii.依赖Struts2
b)原始类型
i.IoC
ii.依赖Struts2
7、包含文件配置
02 Struts2-Result
一、Result类型 (type)
1、dispatcher
运用服务器跳转 jsp forward
不可以是Action,只可以跳转到视图
2、redirect
客户端跳转(重定向)-url发生变化
不可以是Action,只可以跳转到视图
3、chain
跳转到Action (forward action)
可以动用到Action
在访问Action时,Action前面不要加”/”
4、redirectAction
客户端跳转到Action――-url发生变化
5、freemarker
6、httpheader
发送一个http头
7、stream
下载
8、velocity
9、xslt
10、plaintext
返回页面的源码
11、titles
把页面分成几块，每个页面都可以动态的指定
<struts>
<constant name="struts.devMode"value="true"/>
<package name="resultTypes"namespace="/r"extends="struts-default"> <action name="r1">
<result type="dispatcher">/r1.jsp</result>
</action>
<action name="r2">
<result type="redirect">/r2.jsp</result>
</action>
<action name="r3">
<result type="chain">r1</result>
</action>
<action name="r4">
<result type="redirectAction">r2</result>
</action>
</package>
</struts>
注：当访问不同的namespace下的Action时，则使用如下方式：
<result type="chain">
<param name="actionName">dashboard</param>//Action名称
<param name="namespace">/secure</param>//namespace值
</result>
二、全局结果集(Globle Result)
当有多个Action使用同一个结果集时，则可以使用全局结果集(Globle Result),如下：
<package name="user"namespace="/user"extends="struts-default">
<global-results>
<result name="mainpage">/main.jsp</result>
</global-results>
<action name="index">
<result>/index.jsp</result>
</action>
<action name="user"class="erAction"> <result>/user_success.jsp</result>
<result name="error">/user_error.jsp</result>
</action>
</package>
Action所对应的Action类如下：
UserAction
public class UserAction extends ActionSupport {
private int type;
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
@Override
public String execute() throws Exception {
if(type == 1) return"success";
else if (type == 2) return"error";
else return"mainpage";
}
}
UserAction返回的结果集中有”mainpage”，但是user的Action中并没有”mainpage”的Rsult，这时就会使用全局的结果庥(global-result),这人结果集中有”mainpage”
当其它不同的package需要使用这个全局的Result时，则需要使用<package>标签中的extends属性来指定继承包含全局的package就可以了。

如下：
<package name="admin"namespace="/admin"extends="user">
<action name="admin"class="er.action.AdminAction"> <result>/admin.jsp</result>
</action>
</package>
这时package=”user”中的结果集就可以被package=”admin”中的Action使用了。

三、动态的结果集(dynamic result)
<struts>
<constant name="struts.devMode"value="true"/>
<package name="user"namespace="/user"extends="struts-default">
<action name="user"class="erAction">
<result>${r}</result>
</action>
</package>
</struts>
注：${}:作用是用于在配置文件中从Value stack(值栈)中取值。

例如：${r} 表示从Value stack(值栈)中取rAction的(成员属性)的值。

注意这个成员属性必需具有注：此处的${}不是el表达式。

get/set方法。

Action类中指定了r的值。

这样就动态确定了Result的值
public class UserAction extends ActionSupport {
private int type;
private String r;
public String getR() {
return r;
}
public void setR(String r) {
this.r = r;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
@Override
public String execute() throws Exception {
if(type == 1) r="/user_success.jsp";
else if (type == 2) r="/user_error.jsp";
return"success";
}
}
四、带参数的结果集
也就是向结果集传参数
服务器forward共享一个值栈(Value stack)
客户端跳转则不共享
例如：
<package name="user"namespace="/user"extends="struts-default">
<action name="user"class="erAction">
<result type="redirect">/user_success.jsp?t=${type}</result>
</action>
</package>
UserAction类：
public class UserAction extends ActionSupport {
private int type;
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
@Override
public String execute() throws Exception {
return"success";
}
}
因为当执行Action后，已经将Action的成员属性写入了值堆栈了，因此可以在配置文件中使用${type}取出type的值。

但是只有Action才具有值堆栈的。

Jsp是没有什么值堆栈的。

因为当result重新定向到
/user_success.jsp?t=${type}后，是不能从值堆栈中取出t的值。

但是有ActionContext的，所以可以从中取出t的值。

JSP代码如下：
<body>
User Success!
from valuestack: <s:property value="t"/><br/>
from actioncontext: <s:property value="#parameters.t"/>
<s:debug></s:debug>
</body>
注：<s:property value="t"/>取不到值，因为jsp不是一个Action没有值堆栈。

<s:property value="#parameters.t"/>可以取出t的值，因为#方式是从ActionContext中取属性值。

ActionContext堆栈中具有parameters这个属性是用于存储传入的参数。

所以可以取出。

五、Result总结
1、常用的四种类型
a)dispatcher(默认)
b)redirect
c)chain
d)redirectAction
2、全局结果集
a)Global-result | extends
3、动态结果集(了解)
a)在Action中保存一个属性，存储具体的结果location
4、传递参数
a)客户端跳转才需要传递
b)${}表达式（不是el表达式）
六、项目经理：
1、界面原型
2、设计数据库
3、使用什么框架构
4、设计约定(硬编码) ***
项目名称、数据库名称、配置文件名称、Action、JSP……
03 OGNL表达式语言
Object Graph Navigation Language 对象图导航语言
<s:property value=””> 注意： value里的内容称为ognl表达式
User.xxx 只有传入参数，才会构造对象，或者直接在action中new也可以，但是User对象必需具有无参数的构造方法。

{}大括号在OGNL中可以表示一个集合
OGNL表达式语言访问静态方法，需要在Struts2.xml配置文件如下：
<constant name="struts.ognl.allowStaticMethodAccess"value="true"></constant>
使用一个实例如说明OGNL表达式语言，如下：
Cat类
package com.wjt276.struts2.ognl;
public class Cat {
private Dog friend;
public Dog getFriend() {
return friend;
}
public void setFriend(Dog friend) {
this.friend = friend;
}
public String miaomiao() {
return"miaomiao";
}
}
Dog类
package com. wjt276.struts2.ognl;
public class Dog {
private String name;
public Dog() { }
public Dog(String name) {
super();
= name;
}
public String getName() {
return name;
}
public void setName(String name) {
= name;
}
@Override
public String toString() {
return"dog: " + name;
}
}
S类
package com. wjt276.struts2.ognl;
public class S {
public static String STR = "STATIC STRING";
public static String s() {
return"static method"; }}
User类
package com. wjt276.struts2.ognl;
public class User {
private int age = 8;
public User() {}
public User(int age) {
super();
this.age = age;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return"user" + age;
}
}
OgnlAction类
package com. wjt276.struts2.ognl;
public class OgnlAction extends ActionSupport {
private Cat cat;
private Map<String, Dog> dogMap = new HashMap<String, Dog>();
private Set<Dog> dogs = new HashSet<Dog>();
private String password;
private User user;
private String username;
private List<User> users = new ArrayList<User>();
public OgnlAction() {
users.add(new User(1));
users.add(new User(2));
users.add(new User(3));
dogs.add(new Dog("dog1"));
dogs.add(new Dog("dog2"));
dogs.add(new Dog("dog3"));
dogMap.put("dog100", new Dog("dog100"));
dogMap.put("dog101", new Dog("dog101"));
dogMap.put("dog102", new Dog("dog102"));。