`

Struts2学习笔记

 
阅读更多

目录

Ø Action

n 简单数据校验

Ø Result

Ø 常用配置文件

Ø OGNL & ValueStack

Ø Tags

Ø ---------------------Project

n 类型转换、上传与下载、interceptor、防止重复提交

Ø MVC思想深入剖析

Ø 源码解读

Ø 其他话题

 

 

 

01 Struts2-Action

一、Struts作用：

将请求与结果分开

 

二、搭建Struts2的运行环境：

1、建立Web项目；

2、建立Struts2的配置文件(struts.xml)；

将Struts2的空项目中的配置文件(struts.xml)复制到项目的src目录下。

配置如下：

<!--

struts.devMode :　是否设置为开发模式　true:是开发模式，否则不是

注：在开发模式下，修改Struts的配置文件后不需要重新启动Tomcat服务器即生效。

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

-->

<constantname="struts.devMode"value="true"/>

 

<!--

namespace :对应与项目名称后面的"/"(例如Struts2_0100_Introduction后面的"/")

(http://localhost:8080/Struts2_0100_Introduction/)

-->

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

<actionname="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来区分。前台<packagename="front">后台<package name="back">

struts2中的package与java的package是相同的作用的。

五、Action

具体视图的返回可以由用户自己定义的Action来决定

具体的手段是根据返回的字符串找到对应的配置项，来决定视图的内容，有三种手段：

 

<constantname="struts.devMode"value="true"/>

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

<actionname="index"class="com.bjsxt.struts2.front.action.IndexAction1">

<resultname="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()方法就可以了。

importcom.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()方法就可以了。

 

importcom.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=来指定执行哪个方法

<actionname="userAdd"class="com.bjsxt.struts2.user.action.UserAction"method="add">

<result>/user_add_success.jsp</result>

</action>

这样，只要在action的对象中有一个add的方法，并且返回类型为String就可以了。如果没有method属性，则默认执行execute()方法。

importcom.opensymphony.xwork2.ActionSupport;

public class UserAction extends ActionSupport {

public String add() {

returnSUCCESS;

}

}

2、动态方法调用DMI(推荐)

可以在url地址中动态指定action执行那个方法。Url地址如下：

方法：action + ! + 方法名

注：只要Action对象中有这个方法，并且返回类型为String就可以调用。

这样Struts.xml配置文件中不需要配置methed属性。代码如下：

<actionname="user"class="com.bjsxt.struts2.user.action.UserAction">

<result>/user_add_success.jsp</result>

</action>

Action类：

public class UserAction extends ActionSupport {

public Stringadd() {

returnSUCCESS;

}

}

总结：推荐使用第二种动态方法调用DMI，因为第一种需要大量的Action配置，后者可以在url中动态指定执行action中哪个方法。

八、Action通配符(wildcard)的配置

使用通配符，将配置量降到最低, 不过，一定要遵守"约定优于配置"的原则

1、通配符

星号(*) 表示所有

{数字}　表示第几个通配符

例如：Student* 那么{1}代表第一个星号(*)

*_* 那么{1}代表第一个星号(*) ，{2}代表第二个星号(*)

2、实例

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

<actionname="Student*"class="com.bjsxt.struts2.action.StudentAction"method="{1}">

<result>/Student{1}_success.jsp</result>

</action>

 

<actionname="*_*"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地址：

其中传递了两个参数：name和age,其值分别为：a、8，此Action执行的是add()方法。

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

public class UserAction extends ActionSupport {

 

private Stringname;

private int age;

 

public String add() {

System.out.println("name=" +name);

System.out.println("age=" +age);

returnSUCCESS;

}

public String getName() {

returnname;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

returnage;

}

public void setAge(int age) {

this.age = age;

}

}

2、 域模型(Domain Model)

就是利用对象域来进行传递和接受参数

例如请求的URL地址：

其中，访问的是namespace=”/user” action的name=”user” Action所执行的方法method=”add”

利用对象域user来传递参数,为对象的属性赋值(user.name=auser.age=8)

注：需要一个对象user　并且这个对象需要有两个成员属性，且具有get、set方法。

然后在Action中添加一个User对象的成员属性。并且有get、set方法，就可以了。

//User对象

public class User {

private Stringname;

private int age;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

}

 

//Action类

public class UserAction extends ActionSupport {

private Useruser;

//private UserDTO userDTO;

public String add() {

System.out.println("name=" +user.getName());

System.out.println("age=" +user.getAge());

return SUCCESS;

}

 

public User getUser() {

returnuser;

}

public void setUser(User user) {

this.user = user;

}

}

3、 ModelDriven接收参数

使Action实现com.opensymphony.xwork2.ModelDriven<User>(在实现接口时需要使用泛型，否则使用时需要转型)中利用其getModel()方法返回对象模型，从而获得传入的参数。

例如URL如下：

其：访问的是namespace=”/user” action的name=”user” Action所执行的方法method=”add”，其传入了两个参数：name=a,age=8。

参数被传入至Action后，会被ModelDriven对象根据参数名自动赋值给User对象相应的属性而生成User对象，并且由getModel()返回。那么我们在Action中就可以利用这个对象了。

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

对象模型User:

public class User {

private Stringname;

private int age;

public String getName() {

returnname;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

returnage;

}

public void setAge(int age) {

this.age = age;

}

}

Action对象

importcom.opensymphony.xwork2.ActionSupport;

importcom.opensymphony.xwork2.ModelDriven;

public class UserAction extends ActionSupportimplements ModelDriven<User>{

private Useruser = 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>

<constantname="struts.devMode"value="true"/>

<constantname="struts.i18n.encoding"value="GBK" /><!--internationalization -->

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

<actionname="userAdd"class="com.bjsxt.struts2.user.action.UserAction"method="add">

<result>/user_add_success.jsp</result>

</action>

</package>

</struts>

但是，在Struts2 2.7之前，这个配置无效，需要其它方法设置。如下：

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

十一、 简单数据验证

使用addFieldError方法和s:fieldError标签简单处理数据校验

场景：对一个用户名进行验证，如果用户名不合法，则显示给客户端查看信息。

URL请求地址：

分析：访问的Struts2配置,namespace=”/user”action的name=”user” Action所执行的方法method=”add”并且传入了一个参数name=a.如下：

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

<actionname="user"class="com.bjsxt.struts2.user.action.UserAction">

<result>/user_add_success.jsp</result>

<resultname="error">/user_add_error.jsp</result>

</action>

</package>

根据配置文件可以得知action所对应的类为com.bjsxt.struts2.user.action.UserAction,并且具有两个结果集(success和error).代码如下：

importcom.opensymphony.xwork2.ActionSupport;

public class UserAction extends ActionSupport {

private Stringname;

public String add() {

if(name ==null || !name.equals("admin")) {

//addFieldError添加错误信息，可以在客户端访问到。

this.addFieldError("name","name is error");

this.addFieldError("name","name is too long");

returnERROR;

}

returnSUCCESS;

}

public String getName() {

returnname;

}

public void setName(String name) {

this.name = name;

}

}

根据Action类代码，可以看到Action是利用Action的成员属性(name)来接受参数值，并且使用this.addFieldError()方法添加错误信息，以便前台可以访问到。

this.addFieldError(name,errorMessage);

注：此方法是使用继承了ActionSupport父类的

name:可以是傻的属性名称，但一般建议使用哪个成员属性出题了，就用那个。当前是因为name没有通过验证，所以使用name

errorMessage:添加的信息

 

在客户端获取这些信息，如下：

<body>

UserAdd Error!

<s:fielderrorfieldName="name"theme="simple"/>

<br/>

<s:propertyvalue="errors.name"/>

<s:debug></s:debug>

</body>

注：使用<s:fielderror>标题，需要使用<%@taglib>命令引用Struts2的标签库如下：

<%@tagliburi="/struts-tags"prefix="s"%>

1、<s:fielderror>标签：获取使用addFieldError()方法添加的信息。

FiledName：指定信息的名称。

Theme:指定显示的主题。

注：使用此标签获取的错误信息，Struts强制添加了css的修饰。生成的HTML代码如下(不长用)：

<ulclass="errorMessage">

<li><span>nameis error</span></li>

<li><span>nameis too long</span></li>

</ul>

Class=”errorMessage”是Struts2已经设置好的一个css了。这个方式不方便我们自定义样式。

 

 

2、<s:debug></s:debug>：这是标签的写方式，会在页面上产生一个链接，点击后显示如下(Struts2生成的一些信息)：

 

3、<s:property>标签：获取值堆栈属性所对应的值。

<s:propertyvalue="errors.name"/>

注：value:指定值堆栈的属性名及数据下标等。

例如：value=”a” 获取Action类的成员属性a的值

Value=”errors”获取errors属性的对象Map值

Value=”errors.name”获取errors属性的对象Map的key为name的value

Value=”errors.name[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");

returnSUCCESS;

}

}

然后在Jsp页面中获取相关web元素。

<body>

UserLogin Success!

<br/>

<s:propertyvalue="#request.r1"/> |<%=request.getAttribute("r1")%> <br/>

<s:propertyvalue="#session.s1"/> |<%=session.getAttribute("s1")%> <br/>

<s:propertyvalue="#application.a1"/> |<%=application.getAttribute("a1")%> <br/>

<s:propertyvalue="#attr.a1"/><br/>

<s:propertyvalue="#attr.s1"/><br/>

<s:propertyvalue="#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)，通过依赖注入、控制反转(原来自己控制，现在由别人来控制值。)

importorg.apache.struts2.interceptor.ApplicationAware;

importorg.apache.struts2.interceptor.RequestAware;

import org.apache.struts2.interceptor.SessionAware;

importcom.opensymphony.xwork2.ActionSupport;

public class LoginAction2 extends ActionSupportimplements 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");

returnSUCCESS;

}

@Override

public void setRequest(Map<String,Object> request) {

this.request = request;

}

@Override

public void setSession(Map<String,Object> session) {

this.session = session;

}

@Override

public voidsetApplication(Map<String, Object> application) {

this.application = application;

}

}

在视图(JSP)页面中获取相关对象，同方式一。

三、方式三：获取原类型

获取是的HttpServletRequest/HttpSession/ServletContext

public class LoginAction3 extends ActionSupport {

 

private HttpServletRequestrequest;

private HttpSessionsession;

private ServletContextapplication;

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

returnSUCCESS;

}

}

 

四、方式四：获取原类型-控制反转

首先需要Action实现org.apache.struts2.interceptor.ServletRequestAware接口，然后重写setServletRequest()方法，获取HttpServletRequest对象，再通过HttpServletRequest对象取昨HttpSession和ServletContext对象。

 

importjavax.servlet.ServletContext;

importjavax.servlet.http.HttpServletRequest;

importjavax.servlet.http.HttpSession;

 

importorg.apache.struts2.interceptor.ServletRequestAware;

importcom.opensymphony.xwork2.ActionSupport;

public class LoginAction4 extends ActionSupportimplements ServletRequestAware {

private HttpServletRequestrequest;

private HttpSessionsession;

private ServletContextapplication;

public String execute() {

request.setAttribute("r1","r1");

session.setAttribute("s1","s1");

application.setAttribute("a1","a1");

returnSUCCESS;

}

@Override

public void setServletRequest(HttpServletRequestrequest) {

this.request = request;

this.session = request.getSession();

this.application =session.getServletContext();

}

}

 

十三、 Struts2配置文件模块化包含(include)

<include>标签

当Struts配置文件比较多，需要模块化划分或分开成为多个配置文件时，这个功能比较好。

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

例如：有一个login.xml配置文件如下：

<?xmlversion="1.0"encoding="UTF-8"?>

<!DOCTYPEstrutsPUBLIC

"-//ApacheSoftware Foundation//DTD Struts Configuration 2.0//EN"

"http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>

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

<actionname="login*"class="com.bjsxt.struts2.user.action.LoginAction{1}">

<result>/user_login_success.jsp</result>

</action>

</package>

</struts>

则需要在struts.xml文件中使用<include>标签将其引入就可以了。Struts.xml如下

<?xmlversion="1.0"encoding="UTF-8"?>

<!DOCTYPEstrutsPUBLIC

"-//ApacheSoftware Foundation//DTD Struts Configuration 2.0//EN"

"http://struts.apache.org/dtds/struts-2.0.dtd">

 

<struts>

<constantname="struts.devMode"value="true"/>

<include file="login.xml" />

</struts>

 

十四、 默认的Action

当用户访问的namespace下一个不存在的Action，则会将使用默认的Action。

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

<struts>

<constantname="struts.devMode"value="true"/>

 

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

<default-action-refname="index"></default-action-ref>

<actionname="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>

<constantname="struts.devMode"value="true"/>

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

<actionname="r1">

<resulttype="dispatcher">/r1.jsp</result>

</action>

 

<actionname="r2">

<resulttype="redirect">/r2.jsp</result>

</action>

 

<actionname="r3">

<resulttype="chain">r1</result>

</action>

 

<actionname="r4">

<resulttype="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),如下：

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

<global-results>

<resultname="mainpage">/main.jsp</result>

</global-results>

<actionname="index">

<result>/index.jsp</result>

</action>

<actionname="user"class="com.bjsxt.struts2.user.action.UserAction">

<result>/user_success.jsp</result>

<resultname="error">/user_error.jsp</result>

</action>

</package>

Action所对应的Action类如下：

UserAction

public class UserAction extends ActionSupport {

private int type;

public int getType() {

returntype;

}

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就可以了。如下：

<packagename="admin"namespace="/admin"extends="user">

<actionname="admin"class="com.bjsxt.struts2.user.action.AdminAction">

<result>/admin.jsp</result>

</action>

</package>

这时package=”user”中的结果集就可以被package=”admin”中的Action使用了。

 

三、动态的结果集(dynamic result)

<struts>

<constantname="struts.devMode"value="true"/>

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

 

<actionname="user"class="com.bjsxt.struts2.user.action.UserAction">

<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 Stringr;

public String getR() {

returnr;

}

public void setR(String r) {

this.r = r;

}

public int getType() {

returntype;

}

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)

客户端跳转则不共享

例如：

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

 

<actionname="user"class="com.bjsxt.struts2.user.action.UserAction">

<resulttype="redirect">/user_success.jsp?t=${type}</result>

</action>

</package>

UserAction类：

public class UserAction extends ActionSupport {

private int type;

public int getType() {

returntype;

}

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>

UserSuccess!

fromvaluestack: <s:propertyvalue="t"/><br/>

fromactioncontext: <s:propertyvalue="#parameters.t"/>

<s:debug></s:debug>

</body>

注：<s:propertyvalue="t"/>取不到值，因为jsp不是一个Action没有值堆栈。

<s:propertyvalue="#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:propertyvalue=””>　注意：value里的内容称为ognl表达式

User.xxx　只有传入参数，才会构造对象，或者直接在action中new也可以，但是User对象必需具有无参数的构造方法。

{}大括号　在OGNL中可以表示一个集合

 

OGNL表达式语言访问静态方法，需要在Struts2.xml配置文件如下：

<constantname="struts.ognl.allowStaticMethodAccess"value="true"></constant>

 

使用一个实例如说明OGNL表达式语言，如下：

Cat类

package com.wjt276.struts2.ognl;

public class Cat {

private Dogfriend;

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 Stringname;

public Dog() { }

public Dog(String name) {

super();

this.name = name;

}

public String getName() {

return name;

}

public void setName(String name) {

this.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 Stringpassword;

private Useruser;

private Stringusername;

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

}

public String execute() {

return SUCCESS;

}

public Cat getCat() {

return cat;

}

public Map<String, Dog>getDogMap() {

return dogMap;

}

public Set<Dog> getDogs() {

return dogs;

}

public String getPassword() {

return password;

}

public User getUser() {

return user;

}

public String getUsername() {

return username;

}

public List<User>getUsers() {

return users;

}

public String m() {

return "hello";

}

public void setCat(Cat cat) {

this.cat = cat;

}

public void setDogMap(Map<String, Dog> dogMap) {

this.dogMap = dogMap;

}

public void setDogs(Set<Dog> dogs) {

this.dogs = dogs;

}

public void setPassword(String password) {

this.password = password;

}

public void setUser(User user) {

this.user = user;

}

public void setUsername(String username) {

this.username = username;

}

public void setUsers(List<User> users) {

this.users = users;

}

}

Struts2.xml配置文件：

<struts>

<constantname="struts.enable.DynamicMethodInvocation"value="false"/>

<constantname="struts.devMode"value="true"/>

<!-- 允许ognl访问静态方法 -->

<constantname="struts.ognl.allowStaticMethodAccess"value="true"></constant>

<includefile="/com/wjt276/struts2/ognl/ognl.xml"/>

</struts>

Com.wjt276.struts2.ognl.ognl.xml配置文件

<packagename="ognl"extends="struts-default">

<actionname="ognl"class="com.wjt276.struts2.ognl.OgnlAction">

<result>/ognl.jsp</result>

</action>

</package>

客户端请求的URL地址：

分析：此请求是访问action的name=”ognl.action”namespace=”/” 并传入了几个参数(前两个由Action的成员属性接受，后一个由Action的成员对象属性user接受。)，根据Struts2配置文件得知此请求转到/ognl.jsp页面。如下：

<ol>

<li>访问值栈中的action的普通属性: username =<s:property value="username"/></li>

<li>访问值栈中对象的普通属性(get set方法)：<s:propertyvalue="user.age"/> |<s:property value="user['age']"/> |<s:property value="user[\"age\"]"/> | wrong:<%--<s:propertyvalue="user[age]"/>--%></li>

<li>访问值栈中对象中的成员对象的普通属性(get set方法):<s:property value="cat.friend.name"/></li>

<li>访问值栈中对象的普通方法：<s:propertyvalue="password.length()"/></li>

<li>访问值栈中对象的普通方法：<s:propertyvalue="cat.miaomiao()"/></li>

<li>访问值栈中action的普通方法：<s:propertyvalue="m()"/></li>

<hr/>

<li>访问静态方法：<s:propertyvalue="@com.wjt276.struts2.ognl.S@s()"/></li>

<li>访问静态属性：<s:propertyvalue="@com.wjt276.struts2.ognl.S@STR"/></li>

<li>访问Math类的静态方法：<s:propertyvalue="@@max(2,3)"/></li>

<hr/>

<li>访问普通类的构造方法：<s:propertyvalue="new com.bjsxt.struts2.ognl.User(8)"/></li><%--返回对象的toString()生成的数据--%>

<hr/>

<li>访问List:<s:propertyvalue="users"/></li>

<li>访问List中某个元素:<s:propertyvalue="users[1]"/></li>

<li>访问List中元素某个属性的集合:<s:propertyvalue="users.{age}"/></li>

<li>访问List中元素某个属性的集合中的特定值:<s:propertyvalue="users.{age}[0]"/> |<s:property value="users[0].age"/></li>

<li>访问Set:<s:propertyvalue="dogs"/></li>

<li>访问Set中某个元素:<s:propertyvalue="dogs[1]"/></li>

<li>访问Map:<s:propertyvalue="dogMap"/></li>

<li>访问Map中某个元素:<s:propertyvalue="dogMap.dog101"/> |<s:property value="dogMap['dog101']"/> |<s:property value="dogMap[\"dog101\"]"/></li>

<li>访问Map中所有的key:<s:propertyvalue="dogMap.keys"/></li>

<li>访问Map中所有的value:<s:propertyvalue="dogMap.values"/></li>

<li>访问容器的大小：<s:propertyvalue="dogMap.size()"/> |<s:property value="users.size"/></li>

<hr/>

<li>投影(过滤)：<s:propertyvalue="users.{?#this.age==1}[0]"/></li>

<li>投影：<s:propertyvalue="users.{^#this.age>1}.{age}"/></li><%--头一个 --%>

<li>投影：<s:propertyvalue="users.{$#this.age>1}.{age}"/></li><%--最后一个--%>

<li>投影：<s:propertyvalue="users.{$#this.age>1}.{age} == null"/></li>

<hr/>

<li>[]:<s:propertyvalue="[0].username"/></li><%--值堆栈中的对象(Object),从上开始的第0个至堆栈底对象 --%>

</ol>

<s:debug></s:debug>

访问后服务器返回给客户端的结果：

1.访问值栈中的action的普通属性: username = u

2.访问值栈中对象的普通属性(get set方法)：9 | 9 | 9 | wrong:

3.访问值栈中对象的普通属性(get set方法):

4.访问值栈中对象的普通方法：1

5.访问值栈中对象的普通方法：

6.访问值栈中action的普通方法：hello

7.访问静态方法：static method

8.访问静态属性：STATIC STRING

9.访问Math类的静态方法：3

10. 访问普通类的构造方法：user8

11. 访问List:[user1, user2, user3]

12. 访问List中某个元素:user2

13. 访问List中元素某个属性的集合:[1, 2, 3]

14. 访问List中元素某个属性的集合中的特定值:1 | 1

15. 访问Set:[dog: dog1, dog: dog2,dog: dog3]

16. 访问Set中某个元素: <!—没有显示是因为在Set中没有排序就不存在的用下标访问了-->

17. 访问Map:{dog102=dog: dog102,dog101=dog: dog101, dog100=dog: dog100}

18. 访问Map中某个元素:dog: dog101 | dog: dog101 |dog: dog101

19. 访问Map中所有的key:[dog102, dog101, dog100]

20. 访问Map中所有的value:[dog: dog102, dog:dog101, dog: dog100]

21. 访问容器的大小：3 | 3

22. 投影(过滤)：user1

23. 投影：[2]

24. 投影：[3]

25. 投影：false

26. []:u

27. [Debug]

04 Struts2-Tags

Struts2标签目录

1、 通用标签

a) Property

b) Set

i.默认为action scope,会将值放入request和ActionContext中

ii.page/request/session/application

c) bean

d) include对中文文件支持的问题，不建议使用，如需要包含，改用jsp包含

e) param

f) debug

2、 控制标签

a) Ifelseif else

b) Iterator

i.collections map enumerateon iteratorarray

c) subset

3、 UI标签

a) Theme

i.Simple xhtml(默认) css_xhtml ajax

4、 AJAX标签

a) 补充

5、 $ #%　的区别

a) $ 用于i18n和Struts配置文件

b) # 取得ActionContext的值

c) % 将原本的文本属性解析为ognl，对于本来就是ognl的属性不起作用

i.参考<s:property>和<s:include>

 

一、 property标签

格式：<s:property value=””default=””escape=”true|false”/>

如果value中的内容为object，则Struts2都会把它解析成ognl表达式

如果里面需要表示为字符串，则需要将内容用单引号括起来

1、 利用ognl表达式取值(例如：取值堆栈中的username值)

<s:propertyvalue="username"/>

2、 取值为字符串

需要将内容用单引号括起来

<s:propertyvalue="’username’"/>

3、 设置默认值-default

如果一个对象值取不到，则可以使用default设置一个默认值。

<s:propertyvalue="admin"default=”管理员”/>

4、 设定HTML-escape

是否设置返回值为HTML原代码样式

true：解析返回值的html代码　false:原封不动返回值

<s:propertyvalue="'<hr/>'"escape="false"/>

 

 

 

 

二、 set标签

注：var　用于设定变量名

value变量值(可以是ognl表达式)，也可以是字符串

scope 就是的作用范围 request sessionpage application action(默认)

 

<li>set 设定adminName值（默认为request 和 ActionContext）:<s:set var="adminName" value="username" /></li>

 

<li>set 从request取值:<s:property value="#request.adminName" /></li>

<li>set 从ActionContext取值:<s:property value="#adminName" /></li>

 

<%--<li>set 设定范围: <s:setname="adminPassword" value="password"scope="page"/></li>

<li>set 从相应范围取值:<%=pageContext.getAttribute("adminPassword") %></li>

--%>

<li>set 设定var，范围为ActionContext:<s:set var="adminPassword" value="password"scope="session"/></li>

<li>set 使用#取值:<s:property value="#adminPassword"/></li>

<li>set 从相应范围取值:<s:property value="#session.adminPassword"/></li>

 

三、 bean标签

定义bean,并使用param来设定新的属性值

<s:beanname="com.bjsxt.struts2.tags.Dog">

<s:paramname="name"value="'pp'"></s:param>

</s:bean>

定义bean，并使用一个变量(var)来接受创建的这个bean，取出值来

<s:beanname="com.bjsxt.struts2.tags.Dog"var="myDog">

<s:paramname="name"value="'oudy'"></s:param>

</s:bean>

拿出值：因为在actionContext中，所以使用#

<s:propertyvalue="#myDog.name"/>

 

当<s:bean>不指定var时，则对象相关属性会在值栈中。如果需要访问，则只能在<s:bean>标签内访问。

当<s:bean>标签结束后，则值栈就不存在这个对象了。

<s:beanname="com.bjsxt.struts2.tags.Dog">

<s:paramname="name"value="'pp'"></s:param>

<s:propertyvalue="name"/>

</s:bean>

 

四、 <include>标签－少使用

包含文件

<li>include _include1.html 包含静态英文文件

<s:includevalue="/_include1.html"></s:include>

</li>

 

<li>include _include2.html 包含静态中文文件

<s:includevalue="/_include2.html"></s:include>

</li>

 

<li>include _include1.html 包含静态英文文件，说明%用法

<s:setvar="incPage"value="%{'/_include1.html'}"/>

<s:includevalue="%{#incPage}"></s:include>

</li>

%{xxx} 强制将xxx内容转换成OGNL表达式

<-- One: -->
<s:include value="myJsp.jsp" />
<-- Two: -->
<s:include value="myJsp.jsp">
 <s:param name="param1" value="value2" />
 <s:param name="param2" value="value2" />
</s:include>
<-- Three: -->
<s:include value="myJsp.jsp">
 <s:param name="param1">value1</s:param>
 <s:param name="param2">value2</s:param>
</s:include>

五、 If elseif else

<li>if elseif else:

age = <s:propertyvalue="#parameters.age[0]"/> <br/>

<s:setvar="age"value="#parameters.age[0]"/>

<s:iftest="#age < 0">wrong age!</s:if>

<s:elseiftest="#parameters.age[0]< 20">too young!</s:elseif>

<s:else>yeah!</s:else><br/>

 

<s:iftest="#parameters.aaa == null">null</s:if>

</li>

 

<s:if test="%{false}">
 <div>Will Not Be Executed</div>
</s:if>
<s:elseif test="%{true}">
 <div>Will Be Executed</div>
</s:elseif>
<s:else>
 <div>Will Not Be Executed</div>

</s:else>

 

 

 

 

六、 Iterator标签

<li>遍历集合：<br/>

<s:iteratorvalue="{1, 2, 3}">

<s:property/> | <!—不需要写其它的，就可以输出数组内的值-->

</s:iterator>

</li>

<li>自定义变量：<br/>

<s:iteratorvalue="{'aaa', 'bbb', 'ccc'}"var="x">

<s:propertyvalue="#x.toUpperCase()"/> |

</s:iterator>

</li>

<li>使用status:<br/>

<s:iteratorvalue="{'aaa', 'bbb', 'ccc'}"status="status">

<s:property/> |

遍历过的元素总数：<s:propertyvalue="#status.count"/> |

遍历过的元素索引：<s:propertyvalue="#status.index"/> |

当前是偶数？：<s:propertyvalue="#status.even"/> |

当前是奇数？：<s:propertyvalue="#status.odd"/> |

是第一个元素吗？：<s:propertyvalue="#status.first"/> |

是最后一个元素吗？：<s:propertyvalue="#status.last"/>

<br/>

</s:iterator>

 

</li>

 

<li>

<s:iteratorvalue="#{1:'a', 2:'b',3:'c'}" >

<s:propertyvalue="key"/> |<s:property value="value"/><br />

</s:iterator>

</li>

 

<li>

<s:iteratorvalue="#{1:'a', 2:'b',3:'c'}" var="x">

<s:propertyvalue="#x.key"/> |<s:property value="#x.value"/><br />

</s:iterator>

</li>

 

七、 Theme

1、 css(覆盖Struts2原来的css)

2、 覆盖单个文件

3、 定义自己的theme

4、 实战

a) 把所有主题定义为simple

b) Fielderror特殊处理

c) 自己控制其他标签的展现

 

 

05设计约定(编码规定)

1、 原则：简单就是美

2、 库名：项目名

3、 表的命名：t_model名

4、 字段：保持和属性名一致(尽量不要起和数据库命名冲突)

5、 用层来划分包

com.wjt276.bbs.action model(bean)service dto(vo)

6、 Action： xxxAction

7、 *.*

8、 前台： /

9、 后台：　/admin

10、Package：　“action” adminAction

 

06 项目开发顺序

1、 建立界面原型

2、 建立Struts.xml

a) 确定namespace

b) 确定packge

c) 确定Action的名称

d) 确定Result

e) 将界面原型页面进行修改，匹配现有设置

f) 测试

3、 建立数据库（或实体类）

4、 建立Model层

5、 建立Service层(后面讲hibernate后再完美)

a) 此时可以使用Junit进行单元测试了

6、 着手开发

 

 

07 声明式异常处理

注：Struts2支持声明式异常处理。

Struts2是通过拦截器(interceptor)来处理声明式异常处理。

要求在DAO、Service、Action层都需要抛出导演就可以了。其它的让Struts2来处理。详细过程如下：

实例：

如果在列表时出现错误，则方法如下：

public List<Category>list()throws SQLException{

Connectionconn = DB.createConn();

Stringsql = "select* from _category";

List<Category>categories = new ArrayList<Category>();

PreparedStatementps = DB.prepare(conn, sql);

ResultSet rs = null;

try {

rs = ps.executeQuery();

Category c = null;

while(rs.next()){

c =new Category();

…………

}

}catch (SQLException e) {

e.printStackTrace();

throw(e);//此处向外抛出异常，让调用它的方法知道

}finally{

DB.close(rs);

DB.close(ps);

DB.close(conn);

 

}

return categories;

}

然后在调用它的Action也向上抛出异常

public String list()throws SQLException{

categories = categoryService.list();

return SUCCESS;

}

注意重点：我们需要在Struts.xml配置文件中配置需要处理的异常就可以了。

<actionname="*-*"class="com.wjt276.bbs2009.action.{1}Action"method="{2}">

<result>/admin/{1}-{2}.jsp</result>

<resultname="input">/admin/{1}-{2}.jsp</result>

<!-- <exception-mapping>标签是映射异常处理。表示映射哪种异常，此处是java.lang.Exception，如果出现异常，那么它会跳转到reslut="error"的结果集，也就是/error.jsp -->

<exception-mappingresult="error"exception="java.lang.Exception"/>

<resultname="error">/error.jsp</result>

</action>

当然，我们也可以将所有的异常使用同一个异常映射，那就是<global-exception-mappings>，需要映射的packge只需要继承此package就可以了。如下：

 

<packagename="bbs2009-deafult"extends="struts-default">

<global-results>

<resultname="error">/error.jsp</result>

</global-results>

 

<global-exception-mappings>

<exception-mappingresult="error"exception="java.lang.Exception"/>

</global-exception-mappings>

</package>

 

<!-- 后台Action的配置区 -->

<packagename="admin"namespace="/admin"extends="bbs2009-default">

<default-action-refname="index"></default-action-ref>

<actionname="index">

<result>index.html</result>

</action>

<actionname="*-*"class="com.wjt276.bbs2009.action.{1}Action"method="{2}">

<result>/admin/{1}-{2}.jsp</result>

<resultname="input">/admin/{1}-{2}.jsp</result>

<resultname="error">/error.jsp</result>

</action>

</package>

注意：如果使用全局异常映射(<global-exception-mappings>)和全局结果集（<global-results>）则需要全局结果集(<global-results>)在前。

如果局部(当前)Action、和全局结果集存在相同的<result>，则使用最近的那个结果。

总结：

1、 在Action中进行异常映射

2、 在package中进行全局异常映射

3、 使用继承共用异常映射

4、 Struts2中异常处理由拦截器实现(观察struts-default.xml)

a) 实际上Struts2的大多数功能都由拦截器实现。

 

 

 

08 国际化

一、 国际化资源文件

命名格式：xxx_语言_国家.properties

例如：app_en_US.properties 表示美国 英语

app_zh_CN.properties 表示中国 汉语

资源文件的编码是使用UTF-8的编码，这样中文也必需是UTF-8的格式，则需要将中文转换成UTF-8的，你可以使用propertiesEditor插件来进行输入中文。

 

app_en_US.properties文件内容

welcome.msg=hello world!

app_zh_CN.properties

welcome.msg=欢迎您！

二、 Java国际化

要求：资源文件要求存放在classpath的根目录下(src下)。

然后再建立一个Java类和一个main方法如下：这样就可以进行国际化处理了。

public static voidmain(String[] args) {

ResourceBundleres = ResourceBundle.getBundle("app",Locale.CHINA);

System.out.println(res.getString("welcome.msg"));

}

注：java.util.ResourceBundle是加载国际化资源文件的类。利用此类的getBundle()方法加载classpath下的指定开头的文件名的国际化资源文件。并且在加载时需要指定加载哪个国家的国际人资源文件。

此实例中的ResourceBundle.getBundle("app",Locale.CHINA);表示加载以"app"开头的国际化资源文件，并且是中国的(对应的zh_CN)的。

一但国际化资源文件加载上来后，就可以使用ResourceBundle类的getSring("welcome.msg")方法获取当前内容。

三、 Struts2国际化

Struts2国际化分为：Action级别、package级别、Application级别

1、 Action级别

条件：要求国际化资源文件名的前缀同相应的Action名，并且国际化资源文件需要与相应的Action在同一个包中

例如：我们需要国际化登录页面。如下

 

原始代码：<body>

Login_input <br>

<form action="admin/Login_login">

username:<inputname="username"type="text"/><br/>

password:<inputname="password"type="password"/>

<input type="submit" value="login">

</form></body>

这里需要对"Login_input"、"username"、"password"、"login"进行国际化。因为登录页面的请求URL为

根据Struts2.xml的配置文件可知对应的Action为LoginAction.java.因为国际化资源文件名应是LoginAction_开头(此处为LoginAction_zh_CN.properties、LoginAction_en_US.properties)如下

 

注意：要求国际化资源文件需要与相应的Action在同一包中（见上第三个图），这样Struts2就可以保证当访问这个LoginAction时国际化资源文件会自动加载。我们在相应的文件中可以直接访问(利用ActionSupport类中的getText()方法。)了。

我们现在只需要将登录页面代码修改就可以了。

 

<body>

<s:propertyvalue="getText('login.title')"/><br>

<formaction="admin/Login-login"method="post">

<s:propertyvalue="getText('login.username')"/><inputname="username"type="text"/><br/>

<s:propertyvalue="getText('login.password')"/><inputname="password"type="password"/>

<inputtype="submit"value="<s:propertyvalue='getText("login.login")'/>">

</form>

<s:debug></s:debug>

</body>

注意：Struts2国际化是使用<s:property value=”getText()”/>来获取信息的。

格式：

<s:propertyvalue="getText('login.title',defaultValue)"/>

其中：getText()是ActionSuppot类中的方法。因为<s:property>标签只可以直接使用Action的方法。方法中的参数一：表示国际化资源文件中的标签，因为要求是字符串，所以使用单引号括起来。

参数二：当没有取出数据时，则使用这个默认的值，可以省略此参数。

 

总结：国际化资源文件建立完、使用标签取值后，其它都将由Struts2来完成。

 

2、 Package级别

Package级别的只是将国际化资源文件建立在package(包)下，要求资源文件名前缀同包名就可以了。

其它的使用同Action级别的一样。

例如：如果在com.wjt276.bbs2009.action包下建立国际化资源文件，则文件名必须以package开头

package_en_US.properties及　package_zh_CN.properties

 

总结：1、包级别的资源文件名，必须以package开头

2、包级别的资源文件可以给此包中的所有Action类使用。

3、 Application级别

Application级别也只是资源文件存放的位置不同，相同的所使用的范围也不一样。

资源文件要求存放在classpath的根目录下。

国际化资源文件以任何名称开头都可以，只是需要在Struts2.xml配置文件中告诉Struts2资源文件是以什么开头的。

例如：现在以项目名为前缀：bbs2009

bbs2009_en_US.properties　及　bbs2009_en_US.properties

 

告诉Struts2资源文件是以什么开头的

<constant name="struts.custom.i18n.resources"value="bbs2009"/>

四、 资源文件中的参数处理

场景：如果一个登录系统，用户登录后页面提示“欢迎您，xxxx”,如果是英文：”Welcome,xxx”

正常应该如下处理：先取职欢迎信息 + 再显示登录的用户名。

<s:propertyvalue="getText('welcome.msg')"/><s:propertyvalue="username"/>

注意：但是这要就需要两个Struts2的标签来完成这件事。

资源文件中welcome.msg的值如下：

welcome.msg=欢迎您,或welcome.msg=Welcome,

我们还有别外一种方式解决它，只需要一个Struts2标签，只是加入一个参数，这个标签是<s:text>。具体方式如下：

首先是资源文件需要修改，如下

 

注意：需要在资源文件中使用{index}来表示传入参数是哪一个。这个index是从0开始

文件中的欢迎您,{0}或Welcome,{0},如果第一个参数传入值为wjt276，那么页面将显示欢迎您,wjt276或Welcome,wjt276

其次需要使用<s:text>标签是获取信息。如下：

<s:textname="welcome.msg">

<s:paramvalue="username"></s:param>

</s:text>

注意：<s:text>标签中的name中的值不需要单引号括起来，因为是OGNL表达式，而<s:property>标签中value=”getText(‘welcome.msg’)”中的值需要用单引号括起来。因为需要传一个字符串

五、 国际化-动态语言切换

在某些网站中，会发现页面中有国家语言的选择，如：中文、英语、日语等语言供您选择。

Struts2也可以实现这种动态语言切换的功能，方法非常的简单。

方法：只需要传入一个参数(参数名必需为request_locale)，参数值为”语言_国家”(也就是资源文件的后缀,如zh_CN、en_US)就可以了。例：如果当前访问的页面为中文并且URL为

如果需要切换成英文，则只需要传入一个参数request_locale=en_US就可以了。URL如下

这样当前进程的浏览器就可以访问这个网站的所有页面为英文，至到这个进程结束，因为Struts2向session中写入locale值

WW_TRANS_I18N_LOCALE=en_US

 

 

09 自定义拦截器

一般99.9%用不上

 

10 类型转换

public class MyPointConverter extendsDefaultTypeConverter{

 

@Override

public ObjectconvertValue(Object value, Class toType) {

if(toType == Point.class) {

Pointp = new Point();

String[]strs = (String[])value;

String[]xy = strs[0].split(",");

p.x = Integer.parseInt(xy[0]);

p.y = Integer.parseInt(xy[1]);

return p;

}

if(toType == String.class) {

return value.toString();

}

returnsuper.convertValue(value,toType);

}

}

public class MyPointConverter extends StrutsTypeConverter{

 

@Override

public Object convertFromString(Map context,String[] values, ClasstoClass) {

 

Point p = new Point();

String[]strs = (String[])values;

String[]xy = strs[0].split(",");

p.x = Integer.parseInt(xy[0]);

p.y = Integer.parseInt(xy[1]);

return p;

 

 

}

 

@Override

public StringconvertToString(Map context, Object o) {

// TODO Auto-generated method stub

return o.toString();

}

}

 

a)三种注册方式：

i.局部：XXXAction-conversion.properties

1.p（属性名称） = converter

ii. 全局：xwork-conversion.properties

1.com.xxx.XXX（类名）= converter

iii. Annotation

b)如果遇到非常麻烦的映射转换

i.request.setAttribute();

ii. session

 

Struts2总结

1.Action

a)namespace（掌握）

b)path（掌握）

c)DMI（掌握）

d)wildcard（掌握）

e)接收参数（掌握前两种）

f)访问request等（掌握Map IOC方式）

g)简单数据验证（掌握addFieldError和<s:fieldError）

2.Result

a)结果类型（掌握四种，重点两种）

b)全局结果（掌握）

c)动态结果（了解）

3.OGNL表达式（精通）

a)# % $

4.Struts标签

a)掌握常用的

5.声明式异常处理（了解）

6.I18N（了解）

7.CRUD的过程（最重要是设计与规划）（精通）

8.Interceptor的原理（掌握）

9.类型转换（掌握默认，了解自定义）

 

分享到：
Spring学习笔记
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    struts2学习笔记.doc

    ### Struts2学习笔记知识点概览 #### 一、环境搭建 **1.1 Struts2简介** - **Struts2概述**：Struts2是一个开源的MVC框架，它结合了Struts 1.x、WebWork和其他一些框架的优点。Struts2的主要目标是简化Web应用程序...

    struts2学习笔记（1）

    ### Struts2学习笔记知识点详解 #### 一、Struts2框架的基本引入步骤 ##### 1. 导入Struts2相关Jar包 在引入Struts2框架时，首先需要将Struts2的相关Jar包导入到项目的类路径中。这些Jar包通常包括核心库以及其他...

    struts2学习笔记

    以上就是Struts2学习笔记中涵盖的主要知识点，这些内容涵盖了从基础到进阶的应用，对于理解和掌握Struts2框架至关重要。尽管对于初学者来说可能有些复杂，但随着深入学习，你会发现Struts2的强大和实用性。

    struts 2 学习笔记

    在Struts2中，学习笔记通常会涵盖以下几个关键概念： 1. **源代码查看和Javadoc**：开发者可以通过查看源代码来理解Struts2的工作原理，而Javadoc则提供了API文档，帮助理解类和方法的功能。 2. **包（Package）和...

    struts2学习笔记(完美总结)——转自OPEN经验库

    Struts2是一个强大的Java web应用程序开发框架，它遵循Model-View-Controller (MVC)设计模式，用于构建可维护性和可扩展性高的企业级应用。本文将深入探讨Struts2的核心概念，包括Action、Result、配置文件、OGNL与...

    张龙圣思园struts2学习笔记word

    张龙圣思园的Struts2学习笔记，无疑为Java开发者提供了一份宝贵的参考资料，它可能涵盖了Struts2的基础概念、核心组件、配置方式以及实战技巧。 首先，让我们深入了解Struts2的核心特性。Struts2是MVC（Model-View-...

    struts2学习笔记总结

    本笔记将全面总结Struts2的核心概念、主要功能以及实际开发中的应用。 一、Struts2概述 Struts2是Apache软件基金会下的一个开源项目，它继承了Struts1的优点并解决了其存在的问题，如性能和灵活性。Struts2的核心是...

Magicbox
Global site tag (gtag.js) - Google Analytics