blogjava-凯发k8网页登录

当jsonplugin遇到cglib

芦苇 — wed, 28 may 2008 10:26:00 gmt

jsonplugin在分析类结构并序列化时，对于cglig动态生成的类也是按照一般类来看待的。这就导致了如下的问题：

在一个应用中，某些情况下，一个服务类返回的实体并不是原有实体类的对象，而是cglib动态生成的子类。例如使用hibernate的时候，某些情况下dao返回的是entityclassname$$enhancerbycglib$$ac21e这样的类的对象。hibernate在这个子类中添加了hibernatelazyinitializer等等的附加属性。由于jsonplugin并不区分类和动态生成的类，所以也会试图序列化hibernatelazyinitializer属性，从而导致出现如下的异常： java.sql.sqlexception: positioned update not supported.
at com.mysql.jdbc.resultset.getcursorname(resultset.java:1800)

另外，cglib生成的类，某些方法上的@json标记奇怪的丢失了。导致标记了@json(serialize=false)的属性也被序列化。

在网上查了很久没有发现相关的文章，所以无奈就自己动手修改jsonplugin的代码了。

类：com.googlecode.jsonplugin.jsonwriter，修改bean()方法：

1     private void bean(object object) throws jsonexception {
2         this.add("{");
3
4         beaninfo info;
5
6         try {
7             class clazz = object.getclass();
8
9             info = ((object == this.root) && this.ignorehierarchy) ? introspector
10                     .getbeaninfo(clazz, clazz.getsuperclass())
11                     : introspector.getbeaninfo(clazz);
12
13             propertydescriptor[] props = info.getpropertydescriptors();
14
15             boolean hasdata = false;
16             for (int i = 0; i < props.length; i) {
17                 propertydescriptor prop = props[i];
18                 string name = prop.getname();
19                 method accessor = prop.getreadmethod();
20                 method baseaccessor = null; //这里增加一个临时变量作为真实希望序列化的属性的accessor方法引用
21                 if (clazz.getname().indexof("$$enhancerbycglib$$") > -1) {  //如果是cglib动态生成的类
22                     try {
23                         //下面的逻辑是根据cglib动态生成的类名，得到原本的实体类名
24                         //例如 entityclassname$$enhancerbycglib$$ac21e这样
25                         //的类，将返回的是entityclassname这个类中的相应方法，若
26                         //获取不到对应方法，则说明要序列化的属性例如hibernatelazyinitializer之类
27                         //不在原有实体类中，而是仅存在于cglib生成的子类中，此时baseaccessor
28                         //保持为null
29                         baseaccessor = class.forname(
30                                 clazz.getname().substring(0,
31                                         clazz.getname().indexof("$$")))
32                                 .getdeclaredmethod(accessor.getname(),
33                                         accessor.getparametertypes());
34                     } catch (exception ex) {
35                         log.debug(ex.getmessage());
36                     }
37                 }
38                 else    //若不是cglib生成的类，那么要序列化的属性的accessor方法就是该类中的方法。
39                     baseaccessor = accessor;
40
41                 //这个判断，根据上面的逻辑，使得仅存在于cglib生成子类中的属性跳过json序列化
42                 if (baseaccessor != null) {
43
44                     //下面的json annotation的获取也修改为从baseaccessor获取，这样避免了
45                     //由于cglib生成子类而导致某些方法上的json annotation丢失导致处理不该
46                     //序列化的属性
47                     json json = baseaccessor.getannotation(json.class);
48                     if (json != null) {
49                         if (!json.serialize())
50                             continue;
51                         else if (json.name().length() > 0)
52                             name = json.name();
53                     }
54
55                     //ignore "class" and others
56                     if (this.shouldexcludeproperty(clazz, prop)) {
57                         continue;
58                     }
59                     string expr = null;
60                     if (this.buildexpr) {
61                         expr = this.expandexpr(name);
62                         if (this.shouldexcludeproperty(expr)) {
63                             continue;
64                         }
65                         expr = this.setexprstack(expr);
66                     }
67                     if (hasdata) {
68                         this.add(',');
69                     }
70                     hasdata = true;
71
72                     object value = accessor.invoke(object, new object[0]);
73                     this.add(name, value, accessor);
74                     if (this.buildexpr) {
75                         this.setexprstack(expr);
76                     }
77                 }
78             }
79         } catch (exception e) {
80             throw new jsonexception(e);
81         }
82
83         this.add("}");
84     }

这样修改之后，原有类中不能存在的属性将不会被序列化，同时，由于不检查生成的类的方法上的json标记，而是检查原有类上的标记，这样避免了由于cglib导致的annotation丢失的问题。

在此依然向诸位询问是否jsonplugin有处理这样的情况的方法。

芦苇 2008-05-28 18:26

]]>

[translation]json与struts2[转]

芦苇 — wed, 28 may 2008 10:20:00 gmt

阅读全文

芦苇 2008-05-28 18:20

]]>

［译］struts menu开发向导 [转]

芦苇 — mon, 24 mar 2008 07:31:00 gmt

strus 2的新表单标志的使用 [转]

芦苇 — tue, 04 mar 2008 02:30:00 gmt

struts 2为大家提供了不少常用的很酷的表单标志，简化了我们程序员的工作。不过，由于这些都是新标志，大家可能在使用上还存在不少疑问。本文将就朋友们的回复、留言或email上的问题，分别对这些酷标志进行讲述。

表单标志使用小技巧

struts 2的表单标志在输出（render）html时，使用了模板的概念，增加了复杂性（因为它不像struts 1.x的表单标志，它通常都是一个标志对应html的一个元素），因此大家在使用时，需要一些技巧：

struts 2的ui标志的表单标志默认是以表格布局，按钮是右对齐的。如果你不喜欢此风格，你可以简单地将标志的“theme”属性设为“simple”，然后用以往的做法自已布局表单元素（注意：此法有利有弊，弊就是当你将“theme”属性设为“simple”时，表单标志以最简单方式输出html，所以你可能失去一些默认输出提供的便利，如：友好的错误信息的显示，或客户端的表单验证等）。当然更好的做法是通过css或自定义主题（theme）然后应用到整个应用程序，这样可以获得一致的页面风格，加强用户体验（我会在以后的文章对此进行讲解）；
当你在页面上加入某些标志（如：等）时，应该通过action来访问页面，而不是通过*.jsp的url直接访问。

下面我将分别对这些标志进行讲述：

1、

大家对的最大的疑问可能是：“如何在默认情况下，选中某些checkbox？”

答案其实很简单，只需要将其“value”属性设为你的要选中的值，如以代码所示：

<%@ page language="java" contenttype="text/html; charset=utf-8" pageencoding="utf-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>

doctype html public "-//w3c//dtd xhtml 1.0 transitional//en" "http://www.w3.org/tr/xhtml1/dtd/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>struts 2 cool tags - <s:checkboxlist/ >title>
<s:head />
head>
<body>
<h2><s:checkboxlist/>h2>
<s:form action="store">
<s:checkboxlist name="skills1"
label="skills 1"
list="{ 'java', '.net', 'ror', 'php' }"
value="{ 'java', '.net' }"/>
<s:checkboxlist name="skills2"
label="skills 2"
list="#{ 1:'java', 2: '.net', 3: 'ror', 4: 'php' }"
listkey="key"
listvalue="value"
value="{ 1, 2, 3 }"/>
s:form>
body>
html>

清单1 webcontent/checkboxlist.jsp

分布运行应用程序，在浏览器中键入：，出现如下图所示页面：

清单2 checkboxlist.jsp页面

2、

大家看struts 2的showcase的例子，的用法如下所示：

<s:doubleselect
tooltip="choose your state"
label="state"
name="region" list="{'north', 'south'}"
value="'south'"
doublevalue="'florida'"
doublelist="top == 'north' ? {'oregon', 'washington'} : {'texas', 'florida'}"
doublename="state"
headerkey="-1"
headervalue="---------- please select ----------"
emptyoption="true"/>

清单3 showcase中

很多朋友问：“上面的‘list’属性只有两个值，如果我有三个或更多的值，‘doublelist’属性应该如何设定呢？”

我建议的做法是先定义一个map类型的对象，键为“list”的集合，值则为“doublelist”的集合，然后“doublelist”的ognl写成“#mymap[top]”，如以下代码所示：

<%@ page language="java" contenttype="text/html; charset=utf-8" pageencoding="utf-8"%>
<%@ taglib prefix="s" uri="/struts-tags"%>

doctype html public "-//w3c//dtd xhtml 1.0 transitional//en" "http://www.w3.org/tr/xhtml1/dtd/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>struts 2 cool tags - <s:doubeselect/ >title>
<s:head />
head>
<body>
<h2><s:doubleselect/>h2>
<s:form action="store">
<s:set name="foobar"
value="#{'java': {'spring', 'hibernate', 'struts 2'}, '.net': {'linq', ' asp.net 2.0'}, 'database': {'oracle', 'sql server', 'db2', 'mysql'}}"/>
<s:doubleselect list="#foobar.keyset()"
doublename="technology"
doublelist="#foobar[top]"
label="technology"/>
s:form>
body>
html>

清单4 webcontent/doubleselect.jsp

分布运行应用程序，在浏览器中键入：，出现如下图所示页面：

清单5 doubleselect.jsp页面

3、

这个标志可能大家不常用，不过本人认为它还是挺有用的。在使用struts 1.x时，因为跳转通常是用forward（而不是redirect）实现的，所以当用户完成请求后，按“f5”刷新页面时，就会重新提交上次的请求，这样经常会出错。要解决这个问题，可以帮你忙。

实现原理

在页面加载时，产生一个guid（globally unique identifier，全局唯一标识符）值的隐藏输入框如：

清单6 的html输出

同时，将guid放到会话（session）中；在执行action之前，“token”拦截器将会话token与请求token比较，如果两者相同，则将会话中的token删除并往下执行，否则向actionerrors加入错误信息。如此一来，如果用户通过某种手段提交了两次相同的请求，两个token就会不同。

具体实现

首先看一下action的代码：

package tutorial;

import com.opensymphony.xwork2.actionsupport;

publicclass cooltagaction extends actionsupport {
privatestaticfinallong serialversionuid =6820659617470261780l;

private string message;

public string getmessage() {
return message;
}

publicvoid setmessage(string message) {
this.message = message;
}

@override
public string execute() {
system.out.println("executing action, your message is " message);
return success;
}
}

清单7 src/tutorial/cooltagaction.java

以上代码一目了然，再看看jsp的写法：

%@ page language="java" contenttype="text/html; charset=utf-8" pageencoding="utf-8" %>
<%@ taglib prefix="s" uri="/struts-tags"%>

doctype html public "-//w3c//dtd xhtml 1.0 transitional//en" "http://www.w3.org/tr/xhtml1/dtd/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>struts 2 cool tags - <s:token/ >title>
<s:head />
head>
<body>
<h2><s:token/>h2>
<s:actionerror />
<s:form action="token">
<s:textfield name="message" label="message"/>
<s:token />
<s:submit />
s:form>
body>
html>

清单8 webcontent/token.jsp

jsp也很简单，就是加入标志。接下来是actoin配置的xml片段：

xml version="1.0" encoding="utf-8"?>

doctype struts public
"-//apache software foundation//dtd struts configuration 2.0//en"
"http://struts.apache.org/dtds/struts-2.0.dtd">

<struts>
<package name="struts2_cool_tags_demo" extends="struts-default">
<action name="token" class="tutorial.cooltagaction">
<interceptor-ref name="defaultstack"/>
<interceptor-ref name="token"/>
<result name="invalid.token">/token.jspresult>
<result>/token.jspresult>
action>
<action name="*">
<result>/{1}.jspresult>
action>
package>
struts>

清单9 src/struts.xml

以上xml片段值注意的是加入了“token”拦截器和“invalid.token”结果，因为“token”拦截器在会话token与请求token不一致时，将会直接返回“invalid.token”结果。

发布运行应用程序，在浏览器中键入：，出现如下图所示页面：

清单10 正常显示的token.jsp页面

随便填点东西并提交页面，一切正常返回以上页面，然后按“f5”刷新页面，在弹出的对话框中点击“retry”，出现如下图所示页面：

清单11 重复提交出错显示

4、、和

这几个标志的使用相对简单，所以我想小举一例即可，以下是jsp的代码：

doctype html public "-//w3c//dtd xhtml 1.0 transitional//en" "http://www.w3.org/tr/xhtml1/dtd/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>struts 2 cool tags - otherstitle>
<s:head />
head>
<body>
<h2>othersh2>
<s:form action="store">
<s:datetimepicker name="birthday" label="birthday"/>
<s:updownselect
label = "favourite countries"
list="#{'england':'england', 'america':'america', 'germany':'germany'}"
name="prioritisedfavouritecountries"
headerkey="-1"
headervalue="--- please order them accordingly ---"
emptyoption="true"/>
<s:optiontransferselect
label="favourite cartoons characters"
name="leftsidecartooncharacters"
lefttitle="left title"
righttitle="right title"
list="{'popeye', 'he-man', 'spiderman'}"
multiple="true"
headerkey="headerkey"
headervalue="--- please select ---"
emptyoption="true"
doublelist="{'superman', 'mickey mouse', 'donald duck'}"
doublename="rightsidecartooncharacters"
doubleheaderkey="doubleheaderkey"
doubleheadervalue="--- please select ---"
doubleemptyoption="true"
doublemultiple="true"/>
s:form>
body>
html>

清单12 webcontent\others.jsp页面

发布运行应用程序，在浏览器中键入：，出现如下图所示页面：

清单13 其它表单标志页面

总结

struts 2在标志上的确比struts 1.x丰富了许多，同时模板机制也给程序员带来不少方便（如果你不太喜欢个性化的风格）。另外，struts 2还有一些ajax（如等）的标志和非表单的ui标志（如等），我会在以后的文章中讲述其使用。

原作者:http://www.blogjava.net/max/archive/2007/05/18/118442.html

芦苇 2008-03-04 10:30

]]>

转换器（converter）——struts 2.0中的魔术师(struts2中数据批量保存)[转别人的]

芦苇 — tue, 04 mar 2008 01:25:00 gmt

阅读全文

芦苇 2008-03-04 09:25

]]>

struts 1.x中批量封装对象

芦苇 — tue, 04 mar 2008 01:19:00 gmt

阅读全文

芦苇 2008-03-04 09:19

]]>

struts2 strus.xml中result类型及含义

芦苇 — fri, 21 dec 2007 05:04:00 gmt

一个提交到服务器的处理通常可以分为两个阶段，第一个阶段查询服务器状态（查询或者更新数据库），第二个阶段选择一个合适的结果页面其返回给用户（这里要讲的result的内容）。

struts2提供了对不同种类返回结果的支持，常见的有jsp，freemarker，velocity等。

struts2支持的不同类型的返回结果为：

名字

说明

chain result

用来处理action链

dispatcher result

用来转向页面，通常处理jsp

freemarker result

处理freemarker模板

httpheader result

用来控制特殊的http行为

redirect result

重定向到一个url

redirect action result

重定向到一个action

stream result

向浏览器发送inputsream对象，通常用来处理文件下载

velocity result

处理velocity模板

xls result

处理xml/xlst模板

plaintext result

显示原始文件内容，例如文件源代码

s2plugins:tiles result

结合tile使用

另外第三方的result类型还包括jasperreports plugin，专门用来处理jasperreport类型的报表输出。

在struts-default.xml文件中已经有了对于所有类型result的定义：

class="com.opensymphony.xwork2.actionchainresult"/>

class="org.apache.struts2.dispatcher.servletdispatcherresult"

default="true"/>

class="org.apache.struts2.views.freemarker.freemarkerresult"/>

class="org.apache.struts2.dispatcher.httpheaderresult"/>

class="org.apache.struts2.dispatcher.servletredirectresult"/>

class="org.apache.struts2.dispatcher.servletactionredirectresult"/>

class="org.apache.struts2.dispatcher.streamresult"/>

class="org.apache.struts2.dispatcher.velocityresult"/>

class="org.apache.struts2.views.xslt.xsltresult"/>

class="org.apache.struts2.dispatcher.plaintextresult" />

class="org.apache.struts2.dispatcher.servletactionredirectresult"/>

class="org.apache.struts2.dispatcher.plaintextresult" />

从上述代码中可以看出在不指定result类型的时候使用dispatcher类型。

定义一个result值，

/thankyou.jsp

由于type默认值是dispatcher，所以这里不需要定义，另外name的默认值为success所以这里也不需要定义。

上述代码可以简写为：

/thankyou.jsp

另外location参数也可以直接卸载result标签内部，所以上述代码的最简单的写法为：

/thankyou.jsp

我们也可以定义多个不同的result

/hello/result.jsp

/hello/error.jsp

/hello/input.jsp

上述代码的含义为，名字为hello的action有三个返回结果，并且都是dispatcher类型（默认类型），这三个返回值的名字分别为success（默认值），error，input，对应的页面的路径分别为/hello/result.jsp，/hello/error.jsp，/hello/input.jsp。

有些时候我们需要一个定义在全局的result，这个时候我们可以在package内部定义全局的result，例如：

/error.jsp

logon!input

动态返回结果

有些时候，只有当action执行完璧的时候我们才知道要返回哪个结果，这个时候我们可以在action内部定义一个属性，这个属性用来存储action执行完璧之后的result值，例如：

private string nextaction;

public string getnextaction() {

return nextaction;

}

在strutx.xml配置文件中，我们可以使用${nextaction}来引用到action中的属性，通过${nextaction}表示的内容来动态的返回结果，例如：

${nextaction}

上述action的execute方法返回next的时候，还需要根据nextaction的属性来判断具体定位到哪个action。

在strutx.xml配置文件中，我们可以使用method=""来设置调用类的哪个方法，这样就可以在一个java类中使用不同的方法来实现不同的功能,就无需每个功能写一类了,例如：

/success.jsp

芦苇 2007-12-21 13:04

]]>

struts2拦截器的使用 (详解)

芦苇 — thu, 22 nov 2007 08:58:00 gmt

芦苇 2007-11-22 16:58 ]]>

struts 2中的ognl [转]

芦苇 — thu, 22 nov 2007 08:58:00 gmt

struts 2中的ognl
本人是一个el（expression language，以下译为表达式语言）的支持者。因为我对<% %>写法极为反感，忘记了在那本书上看到的一句话——“使用标志（tag）的一个目的就是避免在jsp页面中出现过多的<%%>的语句，使页面与后台代码分离。”

表达式语言主要有以下几大好处：

避免(mytype) request.getattribute()和mybean.getmyproperty()之类的语句，使页面更简洁；
支持运算符（如 -*/），比普通的标志具有更高的自由度和更强的功能；
简单明了地表达代码逻辑，使用代码更可读与便于维护。
struts 2中的表达式语言
struts 2支持以下几种表达式语言：

ognl（object-graph navigation language），可以方便地操作对象属性的开源表达式语言；
jstl（jsp standard tag library），jsp 2.0集成的标准的表达式语言；
groovy，基于java平台的动态语言，它具有时下比较流行的动态语言（如python、ruby和smarttalk等）的一些起特性；
velocity，严格来说不是表达式语言，它是一种基于java的模板匹配引擎，具说其性能要比jsp好。
struts 2默认的表达式语言是ognl，原因是它相对其它表达式语言具有下面几大优势：

支持对象方法调用，如xxx.dosomespecial()；
支持类静态的方法调用和值访问，表达式的格式为@[类全名（包括包路径）]@[方法名 | 值名]，例如：@java.lang.string@format('foo %s', 'bar')或@tutorial.myconstant@app_name；
支持赋值操作和表达式串联，如price=100, discount=0.8, calculateprice()，这个表达式会返回80；
访问ognl上下文（ognl context）和actioncontext；
操作集合对象。
ognl的用法
ognl是通常要结合struts 2的标志一起使用，如等。大家经常遇到的问题是#、%和$这三个符号的使用。下面我想通过例子讲述这个问题：

首先新建名为struts2_ognl的web工程，配置开发环境。之前很多朋友在使用struts 2的过程中都遇到乱码问题。当然乱码问题由来已久，而且涉及多方面的知识，所以并非三言两语可以说明白，而且互联网上也已经有很多这方便的文章，大家可以google一下。不过，如果你在开发的过程，多注意一下，避免乱码问题也不难。乱码多数是由于编码与解码所使用的方式不同造成的，所以我建议大家将编码方式都设为“utf-8”，如<%@ page language="java" contenttype="text/html; charset=utf-8" pageencoding="utf-8" %>。另外，在配置web.xml时使用actioncontextcleanup过滤器（filter），如下面代码所示：

     xmlns=""
     xmlns:xsi=""
     xsi:schemalocation=" ">

     struts 2 ognl


         struts-cleanup

             org.apache.struts2.dispatcher.actioncontextcleanup




         struts-cleanup
         /*



         struts2

             org.apache.struts2.dispatcher.filterdispatcher

         struts2
         /*

         index.html

清单1 webcontent/web-inf/web.xml
“#”主要有三种用途：

访问ognl上下文和action上下文，#相当于actioncontext.getcontext()；下表有几个actioncontext中有用的属性：名称作用例子
parameters 包含当前http请求参数的map #parameters.id[0]作用相当于request.getparameter("id")
request 包含当前httpservletrequest的属性（attribute)的map #request.username相当于request.getattribute("username")
session 包含当前httpsession的属性（attribute）的map #session.username相当于session.getattribute("username")
application 包含当前应用的servletcontext的属性（attribute）的map #application.username相当于application.getattribute("username")
attr 用于按request > session > application顺序访问其属性（attribute） #attr.username相当于按顺序在以上三个范围（scope）内读取username属性，直到找到为止

用于过滤和投影（projecting)集合，如books.{?#this.price<100}；
构造map，如#{'foo1':'bar1', 'foo2':'bar2'}。
下面让我们它们的具体写法，首先是action类代码：

package tutorial.action;

import java.util.linkedlist;
import java.util.list;
import java.util.map;

import javax.servlet.servletcontext;
import javax.servlet.http.httpservletrequest;

import org.apache.struts2.interceptor.servletrequestaware;
import org.apache.struts2.interceptor.sessionaware;
import org.apache.struts2.util.servletcontextaware;

import tutorial.model.book;

import com.opensymphony.xwork2.actionsupport;

public class ognlaction extends actionsupport implements servletrequestaware, sessionaware, servletcontextaware   {
     private static final long serialversionuid = 1l;

     private httpservletrequest request;
     private map session;
     private servletcontext application;
     private list books;

     public void setservletrequest(httpservletrequest request) {
         this.request = request;
     }

     @suppresswarnings("unchecked")
     public void setsession(map session) {
         this.session = session;
     }

     public void setservletcontext(servletcontext application) {
         this.application = application;
     }

     public list getbooks() {
         return books;
     }

     @override
     public string execute() {
         request.setattribute("username", "max from request");
         session.put("username", "max from session");
         application.setattribute("username", "max from application");

         books = new linkedlist();
         books.add(new book("978-0735619678", "code complete, second edition", 32.99));
         books.add(new book("978-0596007867", "the art of project management", 35.96));
         books.add(new book("978-0201633610", "design patterns: elements of reusable object-oriented software", 43.19));
         books.add(new book("978-0596527341", "information architecture for the world wide web: designing large-scale web sites", 25.19));
         books.add(new book("978-0735605350", "software estimation: demystifying the black art", 25.19));

         return success;
     }
}清单2 src/tutorial/action/ognlaction.java

以上代码分别在request、session和application的范围内添加“username”属性，然后再在jsp页面使用ognl将其取回。我还创建了book对象的列表用于演示“用于过滤和投影（projecting)集合”的功能，至于book的代码大家可以在我前一文章《在struts 2中实现crud》看到。

下面是ognl.jsp的代码，内容如下：

<%@ page language="java" contenttype="text/html; charset=utf-8" pageencoding="utf-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>

http://www.w3.org/tr/xhtml1/dtd/xhtml1-transitional.dtd">
http://www.w3.org/1999/xhtml">

     struts ognl demo

访问ognl上下文和action上下文

parameters:

request.username:

session.username:

application.username:

attr.username:

用于过滤和投影（projecting)集合

books more than $35

- $

the price of "code complete, second edition" is:

构造map

the value of key "foo1" is

清单3 webcontent/ognl.jsp
以上代码值得注意的是“”，因为“books.{?#this.title=='code complete, second edition'}.{price}”返回的值是集合类型，所以要用“[索引]”来访问其值。

最后是struts 2的配置文件struts.xml，内容如下：

"-//apache software foundation//dtd struts configuration 2.0//en"
"">

             /ognl.jsp


清单4 src/struts.xml

发布运行应用程序，结果如下所示：

清单5 示例运行结果1

“%”符号的用途是在标志的属性为字符串类型时，计算ognl表达式的值。例如在ognl.jsp中加入以下代码：

%的用途

清单6 演示%用途的代码片段
刷新页面，结果如下所示：

清单7 示例运行结果2

“$”有两个主要的用途

用于在国际化资源文件中，引用ognl表达式，例子请参考《在struts 2.0中国际化(i18n)您的应用程序》
在struts 2配置文件中，引用ognl表达式，如

             listphotos.action?albumid=${albumid}
         清单8 演示$用途的代码片段
总结
ognl是一种功能很大的表达式语言，熟悉它可以使我们的开发变得更快捷。

芦苇 2007-11-22 16:58

]]>

struts2 ognl 与 jsp2.1 el 的冲突问题

芦苇 — thu, 22 nov 2007 03:13:00 gmt

由于 nio 带来的性能提升，tomcat6 不能被忽略。

办法1：

改用-------------------------------------------------------------

这样 jsp2.1 el 就不会有问题了。

办法2：对于旧的程序，不愿意改了，可以向后兼容

必须用 servlet 2.5 xsd.

2.5

" xmlns:xsi="http://www.w3.org/2001/xmlschema-instance" xsi:schemalocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">





true

或者在页面中

<%@page  language="java" deferredsyntaxallowedasliteral="true" %>



办法3 ：不用 jsp2.1 el



>   

>     

>       *.jsp

>       true

>     

>   






我现在的疑问

在一个页面中采用两个 el 引擎，是否会对性能造成一定影响？

较小。

西津渡 ,

webwork ognl的list集合与jsp el 冲突问题解决

将：

<ww:radio list="#{"d":"草稿箱","s":"直接发表"}" name="saveposition">ww:radio>

改：

<ww:radio list="#@java.util.hashmap@{"d":"草稿箱","s":"直接发表"}" name="saveposition">ww:radio>

芦苇 2007-11-22 11:13

]]>

struts2与struts1对比

芦苇 — fri, 02 nov 2007 04:07:00 gmt

struts2与struts1对比

struts2与struts1struts2与struts1对比
action 类:
struts1要求action类继承一个抽象基类。struts1的一个普遍问题是使用抽象类编程而不是接口。
struts 2 action类可以实现一个action接口，也可实现其他接口，使可选和定制的服务成为可能。struts2提供一

个actionsupport基类去实现常用的接口。action接口不是必须的，任何有execute标识的pojo对象都可以用作

struts2的action对象。

线程模式:
struts1 action是单例模式并且必须是线程安全的，因为仅有action的一个实例来处理所有的请求。单例策略限制

了struts1 action能作的事，并且要在开发时特别小心。action资源必须是线程安全的或同步的。
struts2 action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生

许多可丢弃的对象，并且不会导致性能和垃圾回收问题）

servlet 依赖:
struts1 action 依赖于servlet api ,因为当一个action被调用时httpservletrequest 和 httpservletresponse

被传递给execute方法。
struts 2 action不依赖于容器，允许action脱离容器单独被测试。如果需要，struts2 action仍然可以访问初始的

request和response。但是，其他的元素减少或者消除了直接访问httpservetrequest 和 httpservletresponse的必要

性。

可测性:
测试struts1 action的一个主要问题是execute方法暴露了servlet api（这使得测试要依赖于容器）。一个第三方

扩展－－struts testcase－－提供了一套struts1的模拟对象（来进行测试）。
struts 2 action可以通过初始化、设置属性、调用方法来测试，“依赖注入”支持也使测试更容易。

捕获输入:
struts1 使用actionform对象捕获输入。所有的actionform必须继承一个基类。因为其他javabean不能用作

actionform，开发者经常创建多余的类捕获输入。动态bean（dynabeans）可以作为创建传统actionform的选择，但是

，开发者可能是在重新描述(创建)已经存在的javabean（仍然会导致有冗余的javabean）。
struts 2直接使用action属性作为输入属性，消除了对第二个输入对象的需求。输入属性可能是有自己(子)属性的

rich对象类型。action属性能够通过 web页面上的taglibs访问。struts2也支持actionform模式。rich对象类型，包

括业务对象，能够用作输入/输出对象。这种 modeldriven 特性简化了taglib对pojo输入对象的引用。

表达式语言：
struts1 整合了jstl，因此使用jstl el。这种el有基本对象图遍历，但是对集合和索引属性的支持很弱。
struts2可以使用jstl，但是也支持一个更强大和灵活的表达式语言－－"object graph notation language"

(ognl).

绑定值到页面（view）:
struts 1使用标准jsp机制把对象绑定到页面中来访问。
struts 2 使用 "valuestack"技术，使taglib能够访问值而不需要把你的页面（view）和对象绑定起来。

valuestack策略允许通过一系列名称相同但类型不同的属性重用页面（view）。
　
类型转换：
struts 1 actionform 属性通常都是string类型。struts1使用commons-beanutils进行类型转换。每个类一个转换

器，对每一个实例来说是不可配置的。
struts2 使用ognl进行类型转换。提供基本和常用对象的转换器。

校验：
struts 1支持在actionform的validate方法中手动校验，或者通过commons validator的扩展来校验。同一个类可以

有不同的校验内容，但不能校验子对象。
struts2支持通过validate方法和xwork校验框架来进行校验。xwork校验框架使用为属性类类型定义的校验和内容校

验，来支持chain校验子属性

action执行的控制：
struts1支持每一个模块有单独的request processors（生命周期），但是模块中的所有action必须共享相同的生命

周期。
struts2支持通过拦截器堆栈（interceptor stacks）为每一个action创建不同的生命周期。堆栈能够根据需要和不

同的action一起使用。

--------------------------------------------------------------------------------
注释struts.action.extension
the url extension to use to determine if the request is meant for a struts action
用url扩展名来确定是否这个请求是被用作struts action，其实也就是设置 action的后缀，例如

struts.configuration
the org.apache.struts2.config.configuration implementation class
org.apache.struts2.config.configuration接口名

struts.configuration.files
a list of configuration files automatically loaded by struts
struts自动加载的一个配置文件列表

struts.configuration.xml.reload
whether to reload the xml configuration or not
是否加载xml配置(true,false)

struts.continuations.package
the package containing actions that use rife continuations
含有actions的完整连续的package名称

struts.custom.i18n.resources
location of additional localization properties files to load
加载附加的国际化属性文件（不包含.properties后缀）

struts.custom.properties
location of additional configuration properties files to load
加载附加的配置文件的位置

struts.devmode
whether struts is in development mode or not
是否为struts开发模式

struts.dispatcher.parametersworkaround
whether to use a servlet request parameter workaround necessary for some versions of weblogic
（某些版本的weblogic专用）是否使用一个servlet请求参数工作区（parametersworkaround）

struts.enable.dynamicmethodinvocation
allows one to disable dynamic method invocation from the url
允许动态方法调用

struts.freemarker.manager.classname
the org.apache.struts2.views.freemarker.freemarkermanager implementation class
org.apache.struts2.views.freemarker.freemarkermanager接口名

struts.i18n.encoding
the encoding to use for localization messages
国际化信息内码

struts.i18n.reload
whether the localization messages should automatically be reloaded
是否国际化信息自动加载

struts.locale
the default locale for the struts application
默认的国际化地区信息

struts.mapper.class
the org.apache.struts2.dispatcher.mapper.actionmapper implementation class
org.apache.struts2.dispatcher.mapper.actionmapper接口

struts.multipart.maxsize
the maximize size of a multipart request (file upload)
multipart请求信息的最大尺寸（文件上传用）

struts.multipart.parser
the org.apache.struts2.dispatcher.multipart.multipartrequest parser implementation for a

multipart request (file upload)
专为multipart请求信息使用的org.apache.struts2.dispatcher.multipart.multipartrequest解析器接口

（文件上传用）

struts.multipart.savedir
the directory to use for storing uploaded files
设置存储上传文件的目录夹

struts.objectfactory
the com.opensymphony.xwork2.objectfactory implementation class
com.opensymphony.xwork2.objectfactory接口（spring）

struts.objectfactory.spring.autowire
whether spring should autowire or not
是否自动绑定spring

struts.objectfactory.spring.useclasscache
whether spring should use its class cache or not
是否spring应该使用自身的cache

struts.objecttypedeterminer
the com.opensymphony.xwork2.util.objecttypedeterminer implementation class
com.opensymphony.xwork2.util.objecttypedeterminer接口

struts.serve.static.browsercache
if static content served by the struts filter should set browser caching header properties or

not
是否struts过滤器中提供的静态内容应该被浏览器缓存在头部属性中

struts.serve.static
whether the struts filter should serve static content or not
是否struts过滤器应该提供静态内容

struts.tag.altsyntax
whether to use the alterative syntax for the tags or not
是否可以用替代的语法替代tags

struts.ui.templatedir
the directory containing ui templates
ui templates的目录夹

struts.ui.theme
the default ui template theme
默认的ui template主题

struts.url.http.port
the http port used by struts urls
设置http端口

struts.url.https.port
the https port used by struts urls
设置https端口

struts.url.includeparams
the default includeparams method to generate struts urls
在url中产生默认的includeparams

struts.velocity.configfile
the velocity configuration file path
velocity配置文件路径

struts.velocity.contexts
list of velocity context names
velocity的context列表

struts.velocity.manager.classname
org.apache.struts2.views.velocity.velocitymanager implementation class
org.apache.struts2.views.velocity.velocitymanager接口名

struts.velocity.toolboxlocation
          the location of the velocity toolbox
           velocity工具盒的位置
struts.xslt.nocache
          whether or not xslt templates should not be cached
           是否xslt模版应该被缓存
在struts2中，action中的getxxx()只在服务器启动时执行一次，一刷新页面显示的数据内容全都没了，这种问题的解

决办法是：
在web.xml中配置struts2.0时，

action2
/*

把/*改成*.ation就ok了
一、struts2配置文件
struts2相关的配置文件有web.xml，struts.xml，struts.properties，
struts-default.xml，velocity.properties，struts-default.vm。其中web.xml，struts.xml是必须的，其它的配置

文件可选择。它们在web应用中的功能如下：
web.xml：包含所有必须的框架组件的web部署描述符。
struts.xml:配置包含result/view类型、action映射、拦截器等的struts2的主要配置文件。
struts.properties：配置struts2的框架属性。
struts-default.xml：在文件在struts-action-x.x.jar中，该文件是应该被包含在struts.xml中的缺省配置。
welocity.properties：重写了velocity的配置文件。
struts-default.vm：相对于velocity的缺省配置。

二、struts2配置元素
struts2核心的配置文件是缺省的struts.xml。
必要的时候，缺省的配置文件可以包含其它的配置文件；struts文件可以放入jar中，并自动插入应用程序，这样每个

模块可以包含自己的配置文件并自动配置。在freemarker和velocity模块中，模板也能从classpath中加载，所以整个

模块可以作为一个简单的jar文件被包含。
struts.xml配置文件可以包含interceptor、action类和results。
struts.xml配置元素说明：

1、packages
packages:packages把actions、results、results types、interceptors
和interceptor-stacks组装到一个逻辑单元中，从概念上讲，packages就像一个对象，可以被其它子包从写，而且可

以拥有自己独立的部分。
name属性是packages的必填元素，它作为一个关键字被后边的包引用；extends元素是可选的，它允许包扩展一个和多

个前边定义的包。注意，
struts.xml文件是至上而下处理的，所有被扩展的包，需要在扩展包前定义。
abstract元素是可选的，它可以申明一个不包含actions的配置文件。

2、namespace
namespace元素把actions细分到逻辑模块，每一个namespace都有自己的
前缀（prefix），namespace避免了action之间的名字冲突，当前缀出现在uri中时，这些标签都是名字空间感知的（

“namespace aware”），所以这些namespace prefix不必嵌入到表单或连接中。
default的namespace是一个空字符串“”，如果在指定的配置文件中，没有找到action，缺省的namespace也会被查找

。local/global策略允许应用程序在action “extends”元素层次结构之外，有全局的action配置。缺省的namespace

也可以不在package中申明。
namespace prefix可以注册为java的申明式安全，以确保授权的用户才能访问namespace的资源。
root namespace(“/”)也被支持，root就是当直接请求context path的时候的namespace。

[个人理解：namespace的用法就像struts1.x中的path一样，只不过它在package中什么路径，而在action中申明

action名子罢了]

3、include
include元素使得框架能应用“divide and conquer”来配置文件。被include
的每个配置文件必须和struts.xml有一样的格式，一个大的项目可以采用这样方式来组织程序模块。
include元素也可以和package交替出现，框架将按照顺序加载配置文件。

4、interceptor configuration
interceptor允许应用程序在action方法执行前后定义执行代码，
interceptor在应用程序开发中十分重要，对于interceptor有许多用例，如validation, property population,

security, logging, 和profiling。
interceptor被定义为一个java类，interceptor也可以组装成interceptor-stack，他们将按照定义的顺序执行。
在struts-default.xml中定义了一些缺省的interceptor-stack,以便框架能很好地运行。

5、action
action是框架的“工作单元”。action可以指定一个interceptor-stack、
一序列的return type和一序列的异常处理，但只有name属性是必须的。

--------------------------------------------------------------------------------
struts2.0简单的例子今天在apache网站上无意中看到了struts项目2.0.8正式发布了，怀着欣喜的心情我下载了

stuts2.0.8完整包。 struts2.0.8是struts项目和webwork2.2项目的合并版本，集成了两大流行mvc框架的优点，对

struts框架来说是一个大的提升，同时也更大程度地简化了开发人员的开发过程。我简单地研究了一下这个新版本，

现在给大家介绍一个入门级的小例子，希望能对学习这个新版本的朋友有点帮助。
这个例子完成了一次url调用返回结果页面的过程。
首先，要从apache网站上下载struts2.0.8的完整包（可以从这里下载：

），解压后需要找到下列几个文

件：
commons-logging-1.0.4.jar
freemarker-2.3.8.jar
ognl-2.6.11.jar
struts2-core-2.0.8.jar
xwork-2.0.3.jar
然后，我们就开始做第一个例子，我们就使用经典的“helloworld”的名字吧！
1．制作目录结构
如下图所示:
stuts2是web应用的根目录。
2．拷贝引用文件
将上面列举的jar文件拷贝到步骤1中制作的目录struts2\web-inf\lib中。
3．制作jsp文件helloworld.jsp

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

hello world!

将该文件拷贝到步骤1中制作的目录struts2\example中。
4．制作java文件helloworld.java

package example;

/** *//**
* set welcome message.
*/
import com.opensymphony.xwork2.actionsupport;
public class helloworld extends actionsupport ...{

public static final string message = "struts is up and running ...";

public string execute() throws exception ...{
setmessage(message);
return success;
}

private string message;

public void setmessage(string message)...{
this.message = message;
}

public string getmessage() ...{
return message;
}
}
使用下面的命令编译这个java文件：
set classpath=yourdirectory\xwork-2.0-beta-1.jar
javac helloworld.java
将编译后的helloworld.class文件拷贝到步骤1中制作的目录struts2\web-inf\classes\example中。
5．制作web应用的描述文件web.xml

http://java.sun.com/xml/ns/j2ee"
xmlns:xsi=""
xsi:schemalocation=" -

app_2_4.xsd"
version="2.4">

struts blank

struts2
org.apache.struts2.dispatcher.filterdispatcher

struts2
/*

index.html

将该文件拷贝到步骤1中制作的目录struts2\web-inf中。
6．制作manifest.mf文件（从其它地方随便找一个即可）
将该文件拷贝到步骤1中制作的目录struts2\meta-inf中。
7．制作struts配置文件struts.xml和struts.properties
struts.xml文件：

"-//apache software foundation//dtd struts configuration 2.0//en"
"">

/example/helloworld.jsp

struts.properties文件：
struts.devmode = true
struts.enable.dynamicmethodinvocation = false
将这两个文件拷贝到步骤1中制作的目录struts2\ web-inf\classes中。
好了整个例子的文件我们都搞定了。
最后，你可以将制作好的web应用struts2拷贝到tomcat下运行。
访问如果能够看到页面上的“struts is up and

running ...”提示信息说明你的例子是正确的。

--------------------------------------------------------------------------------
struts2.0 中文乱码1.为了能正确显示 jsp页面直接写的中文在jsp页面正确显示添加下面字符设置。
<%@ page contenttype="text/html;charset=gbk"%>
2.为了解决form提交到action中的中文参数乱码问题，在src\struts.properties文件添加
struts.i18n.encoding=gbk

或
在struts2-core-2.0.8.jar 包中路径为struts2-core-2.0.8\org\apache\struts2 有一个default.properties

文件
把struts.i18n.encoding=utf-8改为struts.i18n.encoding=gbk 或者在struts.xml里面改
这样在action中取到的参数不用自己手工转码了。

--------------------------------------------------------------------------------
struts 2.0的标志（tag）介绍介绍常用标志前，我想先从总体上，对struts 1.x与struts 2.0的标志库（tag

library）作比较。 struts 1.x struts 2.0
分类将标志库按功能分成html、tiles、logic和bean等几部分严格上来说，没有分类，所有标志都在uri为

“/struts-tags”命名空间下，不过，我们可以从功能上将其分为两大类：非ui标志和ui标志
表达式语言（expression languages）不支持嵌入语言（el） ognl、jstl、groovy和velcity
以上表格，纯属个人总结，如有所不足或错误，请不吝指正

好了，我要开始介绍“常用”（这里所谓的“常用”，是指在已往工作中使用struts里经常用到的）的标志了。

要在jsp中使用struts 2.0标志，先要指明标志的引入。通过在jsp的代码的顶部加入以下代码可以做到这点。
< prefix="s" uri="/struts-tags" %>

非ui标志
if、elseif和else
描述：
执行基本的条件流转。

参数：

名称必需默认类型描述备注
test 是 boolean 决定标志里内容是否显示的表达式 else标志没有这个参数
id 否 object/string 用来标识元素的id。在ui和表单中为html的id属性

例子：

<%@ page contenttype="text/html; charset=utf-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>


        condition flow

condition flow

        " />

            max's file here


            scott's file here


            other's file here



例1 condition.jsp

iterator
描述：
用于遍历集合（java.util.collection）或枚举值（java.util.iterator）。

参数：

名称必需默认类型描述
status 否 string 如果设置此参数，一个iteratorstatus的实例将会压入每个遍历的堆栈
value 否 object/string 要遍历的可枚举的（iteratable）数据源，或者将放入新列表（list）的对象
id 否 object/string 用来标识元素的id。在ui和表单中为html的id属性

例子：

<%@ page contenttype="text/html; charset=utf-8" %>
<%@ page import="java.util.list" %>
<%@ page import="java.util.arraylist" %>
<%@ taglib prefix="s" uri="/struts-tags" %>

<%
    list list = new arraylist();
    list.add("max");
    list.add("scott");
    list.add("jeffry");
    list.add("joe");
    list.add("kelvin");
    request.setattribute("names", list);
%>


        iterator

names:

white

例2 iterator.jsp

i18n
描述：
加载资源包到值堆栈。它可以允许text标志访问任何资源包的信息，而不只当前action相关联的资源包。

参数：

名称必需默认类型描述
value 是 object/string 资源包的类路径（如com.xxxx.resources.appmsg）
id 否 object/string 用来标识元素的id。在ui和表单中为html的id属性

例子：

helloworld=hello wrold!
例3 classes\ applicationmessages.properties

<%@ page contenttype="text/html; charset=utf-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>

        internationization

例3 i18n.jsp

include
描述：
包含一个servlet的输出（servlet或jsp的页面）。

参数：

名称必需默认类型描述
value 是 string 要包含的jsp或servlet
id 否 object/string 用来标识元素的id。在ui和表单中为html的id属性

例子：

<%@ page contenttype="text/html; charset=utf-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>

        iterator

interator page

            max

i18n

例4 include.jsp

param
描述：
为其他标签提供参数,比如include标签和bean标签. 参数的name属性是可选的,如果提供，会调用component的方法

addparameter(string, object), 如果不提供，则外层嵌套标签必须实现unnamedparametric接口(如texttag)。

value的提供有两种方式,通过value属性或者标签中间的text,不同之处我们看一下例子:

blue

(a)参数值会以string的格式放入statck.
(b)该值会以java.lang.object的格式放入statck.

参数：

名称必需默认类型描述
name 否 string 参数名
value 否 string value表达式
id 否 object/string 用来标识元素的id。在ui和表单中为html的id属性

例子：
请参考例4。

set
描述：
set标签赋予变量一个特定范围内的值。当希望给一个变量赋一个复杂的表达式,每次访问该变量而不是复杂的表达式

时用到。其在两种情况下非常有用: 复杂的表达式很耗时 (性能提升) 或者很难理解 (代码可读性提高)。

参数：

名称必需默认类型描述
name 是 string 变量名字
scope 否 string 变量作用域,可以为application, session, request, page, 或action.
value 否 object/string 将会赋给变量的值
id 否 object/string 用来标识元素的id。在ui和表单中为html的id属性

例子：
请参考例1。

text
描述：
支持国际化信息的标签。国际化信息必须放在一个和当前action同名的resource bundle中,如果没有找到相应

message,tag body将被当作默认message,如果没有tag body,message的name会被作为默认message。

参数：

名称必需默认类型描述
name 是 string 资源属性的名字
id 否 object/string 用来标识元素的id。在ui和表单中为html的id属性

例子：
请参考例3。

url
描述：
该标签用于创建url,可以通过"param"标签提供request参数。

当includeparams的值时'all'或者'get', param标签中定义的参数将有优先权,也就是说其会覆盖其他同名参数的值

。

参数：略

例子：

<%@ page contenttype="text/html; charset=utf-8" %>
<%@ taglib prefix="s" uri="/struts-tags" %>


        url

url

            max

        if\elseif\else


例5 url.jsp

property
描述：
得到'value'的属性,如果value没提供,默认为堆栈顶端的元素。

参数：

名称必需默认类型描述
default 否 string 如果属性是null则显示的default值
escape 否 true booelean 是否escape html
value 否栈顶 object 要显示的值
id 否 object/string 用来标识元素的id。在ui和表单中为html的id属性

例子：
请参考例2。

--------------------------------------------------------------------------------
ui标志ui标志又可以分为表单ui和非表单ui两部分。表单ui部分基本与struts 1.x相同，都是对html表单元素的包装

。不过，struts 2.0加了几个我们经常在项目中用到的控件如：datepicker、doubleselect、timepicker、

optiontransferselect等。因为这些标志很多都经常用到，而且参数也很多，要在一篇文章详细说明并非易事。

需要深入了解这些标志的朋友，可以到以下查看以下网址：
webwork2文档中文化计划（中文）
tag developers guide（英文）
本文有相当的内容也来自这两处。

--------------------------------------------------------------------------------
struts 2.0的action讲解http://www.blogjava.net/max/archive/2006/10/25/77157.html

当请求helloworld.action发生时，struts运行时（runtime）根据struts.xml里的action映射集(mapping)，实例化

tutoiral.helloworld类，并调用其execute方法。当然，我们可以通过以下两种方法改变这种默认调用。这个功能

（feature）有点类似struts 1.x中的lookupdispathaction。

在classes/sturts.xml中新建action，并指明其调用的方法；
访问action时，在action名后加上“!xxx”（xxx为方法名）。
现方法一，在classes/sturts.xml中加入下面代码：

/helloworld.jsp
例2 classes/struts.xml中alaishelloworld action的配置
通过上面的两个例子，细心的朋友应该可能会发现classes/tutorial/helloworld.java中action方法（execute和

aliasaction）返回都是success。这个属性变量我并没有定义，所以大家应该会猜到它在actionsupport或其父类中定

义。没错，success在接口com.opensymphony.xwork2.action中定义，另外同时定义的还有error, input, login,

none。

此外，我在配置action时都没有为result定义名字（name），所以它们默认都为success。值得一提的是struts 2.0中

的result不仅仅是struts 1.x中forward的别名，它可以实现除forward外的很激动人心的功能，如将action输出到

freemaker模板、velocity模板、jasperreports和使用xsl转换等。这些都过result里的type（类型）属性

（attribute）定义的。另外，您还可以自定义result类型。

下面让我们来做一个velocity模板输出的例子，首先在classes/struts.xml中新建一个action映射（mapping），将其

result类型设为velocity，如以下代码所示：

/helloworld.vm
例3 classes/struts.xml中vmhelloworld action的配置

新建helloworld.vm，内容如下所示：

    velocity

message rendered in velocity: $message

例3 helloworld.vm

很多时候我的同事会问我：“如果我要取得servlet api中的一些对象，如request、response或session等，应该怎么

做？这里的execute不像struts 1.x的那样在参数中引入。”开发web应用程序当然免不了跟这些对象打交道。在

strutx 2.0你可以有两种方式获得这些对象：非ioc（控制反转inversion of control）方式和ioc方式。

非ioc方式

要获得上述对象，关键struts 2.0中com.opensymphony.xwork2.actioncontext类。我们可以通过它的静态方法

getcontext()获取当前action的上下文对象。另外，org.apache.struts2.servletactioncontext作为辅助类

（helper class），可以帮助您快捷地获得这几个对象。

httpservletrequest request = servletactioncontext.getrequest();
httpservletresponse response = servletactioncontext.getresponse();
httpsession session = request.getsession();
如果你只是想访问session的属性（attribute），你也可以通过actioncontext.getcontext().getsession()获取或添

加session范围（scoped）的对象。

ioc方式

要使用ioc方式，我们首先要告诉ioc容器（container）想取得某个对象的意愿，通过实现相应的接口做到这点。具体

实现，请参考例6 iocservlet.java。
package tutorial;

import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
import javax.servlet.http.httpsession;

import org.apache.struts2.servletactioncontext;

import com.opensymphony.xwork2.actioncontext;
import com.opensymphony.xwork2.actionsupport;

publicclass noniocservlet extends actionsupport {
    private string message;

    public string getmessage() {
        return message;
    }

    @override
    public string execute() {
        actioncontext.getcontext().getsession().put("msg", "hello world from session!");

        httpservletrequest request = servletactioncontext.getrequest();
        httpservletresponse response = servletactioncontext.getresponse();
        httpsession session = request.getsession();

        stringbuffer sb =new stringbuffer("message from request: ");
        sb.append(request.getparameter("msg"));
        sb.append("
response buffer size: ");
        sb.append(response.getbuffersize());
        sb.append("
session id: ");
        sb.append(session.getid());

        message = sb.tostring();
        return success;
    }
}例6 classes/tutorial/noniocservlet.java

package tutorial;

import java.util.map;

import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
import javax.servlet.http.httpsession;

import org.apache.struts2.interceptor.servletrequestaware;
import org.apache.struts2.interceptor.servletresponseaware;
import org.apache.struts2.interceptor.sessionaware;

import com.opensymphony.xwork2.actioncontext;
import com.opensymphony.xwork2.actionsupport;

publicclass iocservlet extends actionsupport implements sessionaware, servletrequestaware,

servletresponseaware {
    private string message;
    private map att;
    private httpservletrequest request;
    private httpservletresponse response;

    public string getmessage() {
        return message;
    }

    publicvoid setsession(map att) {
        this.att = att;
    }

    publicvoid setservletrequest(httpservletrequest request) {
        this.request = request;
    }

    publicvoid setservletresponse(httpservletresponse response) {
        this.response = response;
    }

    @override
    public string execute() {
        att.put("msg", "hello world from session!");

        httpsession session = request.getsession();

        stringbuffer sb =new stringbuffer("message from request: ");
        sb.append(request.getparameter("msg"));
        sb.append("
response buffer size: ");
        sb.append(response.getbuffersize());
        sb.append("
session id: ");
        sb.append(session.getid());

        message = sb.tostring();
        return success;
    }
}例6 classes/tutorial/iocservlet.java

<%@ page contenttype="text/html; charset=utf-8" %>
<%@ taglib prefix="s" uri="/struts-tags"%>

hello world!

message from session:

例6 servlet.jsp

/servlet.jsp

/servlet.jsp

--------------------------------------------------------------------------------
在src文件夹中加入struts.properties文件，内容如下：
struts.custom.i18n.resources=globalmessages
struts 2.0有两个配置文件，struts.xml和struts.properties都是放在web-inf/classes/下。
struts.xml用于应用程序相关的配置
struts.properties用于struts 2.0的运行时（runtime）的配置

在src文件夹中加入globalmessages_en_us.properties文件，内容如下：
helloworld=hello world!
在src文件夹中加入globalmessages_zh_cn.properties文件，内容如下：
helloworld=你好，世界！

在webcontent文件夹下加入helloworl.jsp文件，内容如下：
<%@ page contenttype="text/html; charset=utf-8"%>
< prefix="s" uri="/struts-tags"%>

hello world

资源文件查找顺序
之所以说struts 2.0的国际化更灵活是因为它可以能根据不同需要配置和获取资源（properties）文件。在struts

2.0中有下面几种方法：

使用全局的资源文件，方法如上例所示。这适用于遍布于整个应用程序的国际化字符串，它们在不同的包（package）

中被引用，如一些比较共用的出错提示；
使用包范围内的资源文件。做法是在包的根目录下新建名的package.properties和package_xx_xx.properties文件。

这就适用于在包中不同类访问的资源；
使用action范围的资源文件。做法为action的包下新建文件名（除文件扩展名外）与action类名同样的资源文件。它

只能在该action中访问。如此一来，我们就可以在不同的action里使用相同的properties名表示不同的值。例如，在

actonone中title为“动作一”，而同样用title在actiontwo表示“动作二”，节省一些命名工夫；
使用标志访问特定路径的properties文件。使用方法请参考我早前的文章《常用的struts 2.0的标志（tag）

介绍》。在您使用这一方法时，请注意标志的范围。在到之间，所有的国

际化字符串都会在名为xxxxx资源文件查找，如果找不到，struts 2.0就会输出默认值（国际化字符串的名字）。
上面我列举了四种配置和访问资源的方法，它们的范围分别是从大到小，而struts 2.0在查找国际化字符串所遵循的

是特定的顺序，如图3所示：

图3 资源文件查找顺序图
假设我们在某个childaction中调用了gettext("user.title")，struts 2.0的将会执行以下的操作：

查找childaction_xx_xx.properties文件或childaction.properties；
查找childaction实现的接口，查找与接口同名的资源文件myinterface.properties；
查找childaction的父类parentaction的properties文件，文件名为parentaction.properties；
判断当前childaction是否实现接口modeldriven。如果是，调用getmodel()获得对象，查找与其同名的资源文件；
查找当前包下的package.properties文件；
查找当前包的父包，直到最顶层包；
在值栈（value stack）中，查找名为user的属性，转到user类型同名的资源文件，查找键为title的资源;
查找在struts.properties配置的默认的资源文件，参考例1;
输出user.title。
参数化国际化字符串
许多情况下，我们都需要在动行时（runtime）为国际化字符插入一些参数，例如在输入验证提示信息的时候。在

struts 2.0中，我们通过以下两种方法做到这点：

在资源文件的国际化字符串中使用ognl，格式为${表达式}，例如：
validation.require=${gettext(filename)} is required
使用java.text.messageformat中的字符串格式，格式为{ 参数序号（从0开始）, 格式类形（number | date | time

| choice）, 格式样式}，例如：
validation.between=date must between {0, date, short} and {1, date, short}
在显示这些国际化字符时，同样有两种方法设置参数的值：

使用标志的value0、value1...valuen的属性，如：

使用param子元素，这些param将按先后顺序，代入到国际化字符串的参数中，例如：

让用户方便地选择语言
开发国际化的应用程序时，有一个功能是必不可少的——让用户快捷地选择或切换语言。在struts 2.0中，通过

actioncontext.getcontext().setlocale(locale arg)可以设置用户的默认语言。不过，由于这是一个比较普遍的应

用场景（scenario），所以struts 2.0为您提供了一个名i18n的拦截器（interceptor），并在默认情况下将其注册到

拦截器链（interceptor chain）中。它的原理为在执行action方法前，i18n拦截器查找请求中的一个名

为"request_locale"的参数。如果其存在，拦截器就将其作为参数实例化locale对象，并将其设为用户默认的区域

（locale），最后，将此locale对象保存在session的名为“ww_trans_i18n_locale”的属性中。

下面，我将提供一完整示例演示它的使用方法。

package tutorial;

import java.util.hashtable;
import java.util.locale;
import java.util.map;

publicclass locales {
    public map getlocales() {
        map locales =new hashtable(2);
        locales.put("american english", locale.us);
        locales.put("simplified chinese", locale.china);
        return locales;
    }
}tutorial/locales.java

< prefix="s" uri="/struts-tags"%>

" name="langform"
    style="background-color: powderblue; padding-top: 4px; padding-bottom: 4px;">
    language:         list="#locales.locales" listkey="value"    listvalue="key"
        value="#session_locale == null ? locale : #session_locale"
        name="request_locale" id="langselecter"
        onchange="langselecter_onchanged()" theme="simple"/>
langselector.jsp
上述代码的原理为，langselector.jsp先实例化一个locales对象，并把对象的map类型的属性locales赋予下拉列表（

select）。如此一来，下拉列表就获得可用语言的列表。大家看到langselector有标志和一段javascript脚

本，它们的作用就是在用户在下拉列表中选择了后，提交包含“reqeust_locale”变量的表单到action。在打开页面

时，为了下拉列表的选中的当前区域，我们需要到session取得当前区域（键为“ww_trans_i18n_locale”的属性），

而该属性在没有设置语言前是为空的，所以通过值栈中locale属性来取得当前区域（用户浏览器所设置的语言）。

你可以把langselector.jsp作为一个控件使用，方法是在jsp页面中把它包含进来，代码如下所示：

value="/langselector.jsp"/>
在例1中的hellloworld.jsp中后加入上述代码，并在struts.xml中新建action，代码如下：

/helloworld.jsp

或者，如果你多个jsp需要实现上述功能，你可以使用下面的通用配置，而不是为每一个jsp页面都新建一个action。

/{1}.jsp

分布运行程序，在浏览器的地址栏中输入，出现图4所示页

面：

图3 helloworld.action

在下拉列表中，选择“american english”，出现图5所示页面：

图4 helloworld.action
可能大家会问为什么一定要通过action来访问页面呢？
你可以试一下不用action而直接用jsp的地址来访问页面，结果会是无论你在下拉列表中选择什么，语言都不会改变。

这表示不能正常运行的。其原因为如果直接使用jsp访问页面，struts 2.0在web.xml的配置的过滤器（filter）就不

会工作，所以拦截器链也不会工作。

芦苇 2007-11-02 12:07

]]>

深入了解struts中的struts-config.xml

芦苇 — tue, 09 oct 2007 00:50:00 gmt

深入了解struts中的struts-config.xml

弄清楚struts-config.xml中各项元素的作用，对于我们构建web项目有莫大的好处。是struts的根元素，它主要有8个子元素，dtd定义如下：

(data-sources?,form-beans?,global-exceptions?,global-forwards?,action-mappings?,controller?,message-resources*,plug-in*)
>
以上8个元素，下面一一描述：
1. date-sources元素
　　date-sources元素用来配置应用程序所需要的数据源。java语言提供了javax.sql.datesource接口，所有数据源必须实现该接口。如下配置：

　　
　　　　………………
　　

在action中访问方式如：
javax.sql.datasource datasource;
java.sql.connection myconnection;
try
{
　　datasource = getdatasource(request);
　　myconnection　＝　datasource.getconnection();
}
…………
　　如果是多数据源，可用如下配置：

　　
　　　　………………
　　
　　
　　　　………………
　　

访问方式：datasource = getdatasource(request,"a");

2. form-beans元素
　　该元素主要用来配置表单验证的类。它包含如下属性：
　　1. classname：一般用得少，指定和form-bean无素对应的配置类，默认为org.apache.struts.config.formbeanconfig，如果自定义，则必须扩展formbeanconfig类。可有可无。
　　2. name：actionform bean的惟一标识。必须。
　　3. type：actionform的完整类名。必须。
如下所示：

　　　　　　　　name="loign"
　　　　　　type="com.ha.login">
　　

　　如果是动态action formbean，还必须配置form-bean元素的form-property子元素。它包含四个属性，上面三个，还有一个initial 元素：以字符串的形式设置表单字段的初始值，如果没有设置该属性，则是基本类型为0，如果是对象则为null。可有可无。如下所示：

　　　　　　　　name="loign"
　　　　　　type="com.ha.login">
　　　　　
　　　　　
　　　　　
　　

3. global-exceptions元素
　　该元素主要配置异常处理，它的exception子元素代表全局的异常配置。struts采取配置的方式来处理异常。它用来设置java异常和异常处理类org.apache.struts.action.exceptionhandler之间的映射。它有七个属性，如下所示：
　　1. classname：指定和exception元素对应的配置类，默认为：org.apache.struts.config.exceptionconfig。可有可无。
　　2. handler：指定异常得理类，默认为：org.apache.struts.action.exceptionhandler。可有可无
　　3. key：指定在resource bundle中描述该异常的消息key
　　4. path：指定当异常发生时的转发路径。
　　5. scope：指定actionmessages实例的存放范围，可选值包括：request和session，默认为request。可有可无。
　　6. type：指定所需处理异常类的名字，必须。
　　7. bundle：指定resource bundle
如下所示：

　　　　　　　　key="global.error.invalidlogin"
　　　　　　path="/error.jsp"
　　　　　　scope="request"
　　　　　　type="com.hn.tree"
　　/>

4. global-forwards元素
　　该元素主要用来声明全局的转发关系，它具有以下四个属性：
　　1. classname：和forward元素对应的配置类，默认为：org.apache.struts.action.actionforward。可有可无。
　　2. contextrelative：此项为true时，表时path属性以＂/＂开头，相对于当前上下文的url，默认为false．可有可无。　
　　3. name：转发路径的逻辑名．必填。
　　4. path：转发或重定向的url，当contextrelative=false时，url路径相对于当前应用（application），当为ture时，表示url路径相对于当前上下文（context）。
　　5. redirect：当此项为ture时，表示执行重定向操作。当此项为false时表示转向操作。默认为false。
如下所示：

　　
　　

5. action-mappings元素
　　描述从特定的请求路径到相应的action类的映射。它具有以下几个属性：
　　1. attribute：设置和action关联的actionform bean在request和session范围内的key。如：form bean存在于request范围内，此项设为“mybenas”，则在request.getattribute("mybenas")就可以返回该bean的实例。
　　2. classsname：和action元素对应的配置元素，默认为：org.apache.struts.action.actionmapping.
　　3. forward：转发的url路径。
　　4. include：指定包含的url路径。
　　5. input：输入表单的url路径，当表单验证失败时，将把请求转发到该url。
　　6. name：指定和action关联的action formbean的名字，该名字必须在form-bean定义过。
　　7. path：指定访问action的路径，以“/”开头，无扩展名。
　　8. parameter：指定actgion的配置参数，在action类的execute()方法中，可以调用actionmapping对象的getparameter()方法来读取该配置参数。
　　9. roles：指定允许调用该action的安全角色，多个角色之间用，隔开，在处理请求时，requestprocessor会根据该配置项来决定用户是否有权限调用action权限。
　　10. scope：指定actionform bean的存在范围，可选取为request和session，默认为session。
　　11. type：指定action类的完整类名。
　　12. unknown：如果此项为true，表示可以处理用户发出的所有无效的action url，默认为false；
　　13. validate：指定是否要调用action formbean的validate方法，默认值为ture.
注：forward、include、type属性只能选中其中一项。
如下：
　　　　type="zxj.okbean"
　　　　name="a1"
　　　　scope="request"
　　　　validate="true"
　　　　input="/b.jsp">
　　

注：此中的forward是指局部的转发路径。global-forwards表示全局的转发路径。

6. controller元素
　　该元素用于配置actionservlet。它具有以下属性。
　　1. buffersize：指定上载文件的输入缓冲大小，可选，默认为4096
　　2. classname：指定和controller元素对应的配置类，默认为org.apache.struts.config.controllerconfig
　　3. conenttype：字符编码，如果在action和jsp网页中设置了，则覆盖该设置。
　　4. locale：指定是否把locale对象保存到当前用户的session中，默认值为false.
　　5. processorclass：指定负责请求的java类完整路径。
　　6. tempdir：指定处理文件的临时工作目录，如果此项没有设置，将采用servlet容器为web应用分配的临时工作目录。
　　7. nochache：如果为true：在响应结果中将加入特定的头参数：pragma,cache-control和expise，防止页面被保存在客户端的浏览器中，默认为false
如下：
　　contenttype="text/html;charset="utf-8""
　　locale="true"
　　processorclass="con.ok"/>

7. message-resources元素
　　主要配置本地化消息文本，它具有以下属性。
　　1. classname：和message-resources元素对应的配置类，默认为org.apache.struts.config.messageresourcesconfig。
　　2. factory：指定消息资源的工厂类，默认为：org.apache.struts.util.propertymessageresourcesfactory类
　　3. key：指定resource bundle存放的servletcontext对象中时采用的属性key，默认由globals.messages_key定义的字符串常量，只允许一个resource bundle采用默认的属性key。
　　4. null：指定messagesources类如何处理未知消息的key，如果为true，则返回空字符串，如果为false，则返回相关字串，默认为false
　　5. prameter：指定messagesources的资源文件名，如果为：a.b.applicationresources，则实际对应的文件路径为：web-inf/classes/a/b/applicationresources.properties.
如：

访问为：

其中，zxj表法，messagesource资源文件中的一个字符串。

8. plugin-in元素
　　配置struts的插件，属性如下：
　　1. classname：指定的struts插件类，必须实现org.apache.struts.action.plugiin接口。如：
　　classname="a.b.c.">
　　

后记，多模块的配置，可以供多个应用应用不同的struts-config.xml

(转载于：)

芦苇 2007-10-09 08:50

]]>

struts2访问隐藏的request和session

芦苇 — fri, 10 aug 2007 05:12:00 gmt

在struts1.*中，要想访问request、response以及session等servlet对象是很方便的，因为它们一直是作为形参在各个方法之间进行传递的，而在struts2中我们就很难看到它们的芳踪了，因为我们获得表单中的值都是通过预先设置好了的get方法来得到的，那么如果有些参数我们必须通过request.getparametre或者session.getattribute来得到，那么应该怎么做呢？按照max的教程上的说法，可以分为两种：ioc方式和非ioc方式，如何理解这两种方式的区别呢？ioc是spring里面的特征之一，字面意思是反转控制，说白了就是依赖注入，比方说类a依赖类b，那么就主动的给a注入一个类b的对象，下面看一下这两种方法的具体实现。

1．非ioc方式

这种方式主要是利用了com.opensymphony.xwork2.actioncontext类以及org.apache.struts2.servletactioncontext类，具体的方法如下所示。

获得request对象：

a．httpservletrequest request = servletactioncontext.getrequest ();

b．actioncontext ct= actioncontext.getcontext()

httpservletrequest request=

(httpservletrequest)ct.get(servletactioncontext.http_request);

获得session对象：

在struts2中底层的session都被封装成了map类型，我们称之为sessionmap，而平常我们所说的session则是指httpsession对象，具体的获得方法如下所示。

a．map session=actioncontext.getsession();

b．map session=(map)actioncontext.getcontext().get(actioncontext.session);

得到这个sessionmap之后我们就可以对session进行读写了，如果我们想得到原始的httpsession可以首先得到httpservletrequest对象，然后通过request.getsession()来取得原始的httpsession对象。一般情况下sessionmap已经可以完成所有的工作，我们不必再去碰底层的session了。

2．ioc方式

这种方式相对来说变化就比较少了，具体流程如下所示。

获得request对象：

第一步：让action实现servletrequestaware接口

第二步：在action中声明一个httpservletrequest类型的实例变量

第三步：在action中实现servletrequestaware接口的setservletrequest方法，实现方式很简单，如下所示。

private httpservletrequest request;

publicvoid setservletrequest(httpservletrequest request) {

this.request = request;

}

获得session对象(注意，此时的session是sessionmap类型)：

第一步：让action实现sessionaware接口

第二步：在action中声明一个httpservletrequest类型的实例变量

第三步：在action中实现sessionaware接口的setsession方法，实现方式很简单，如下所示。

private map session;

publicvoid setsession(map session) {

this. session = session;

}

trackback: http://tb.blog.csdn.net/trackback.aspx?postid=1721226

芦苇 2007-08-10 13:12

]]>

struts2的struts.properties配置文件详解

芦苇 — fri, 10 aug 2007 05:07:00 gmt

the url extension to use to determine if the request is meant for a struts action
用url扩展名来确定是否这个请求是被用作struts action，其实也就是设置 action的后缀，例如login.do的'do'字。