Ajax快速入门，以XML作为数据载体发送和接收图书信息。

1、创建XMLHttpRequest对象：xmlHttp；
2、以XML数据存储用户选择的图书（ID）；
3、发送异步请求（调用XMLHttpRequest对象的相关方法和设置属性）：
3.1、调用open()方法，设置请求方式（POST/GET/HEAD）和URL;
3.2、调用setRequestHeader()方法，设置请求的报头信息；
3.2、调用send()方法，向服务器发送请求；
3.4、设置onreadystatechange属性，设置回调函数名。
4、XmlBookServlet处理XML字符串并返回XML字符串
4.1、读取请求（request）中的XML字符窜；
BufferedReader reader = request.getReader();
while ((len = reader.read(buf)) != -1) {
xml.append(new String(buf, 0, len));
}
4.2、利用dom4j提供的基于事件的处理模型对XML文档进行解析
saxReader.addHandler()；
4.3、在解析的同时读取数据库中相应的信息（详细信息），并注入对象中；
eltBooks.add(eltBook);
4.4、将对象写入返回响应(response)中：
response.getWriter()
xmlWriter.write(eltBooks);
5、回调函数处理服务器返回结果：
5.1、检查“请求的状态”，4为响应已完成；
5.2、检查“服务器的HTTP状态码”，200为OK；
5.3、清除先前请求的结果，包括表头和内容；
5.4、解析服务器响应的XML数据，构建表头和内容。

孙鑫《Struts2 深入详解》笔记，第18章。

下载

说明：Struts2支持多语言非常方便，只要写好对应的资源文件就可以了。ExtJS的多语言很麻烦，和Struts2配合起来就非常好了。

找到 C:\Documents and Settings\your userName\Application Data\Subversion 这个目录下的servers文件，用任意一个文本编辑器打开，找到
类似于如下的文字：

[global]
# http-proxy-exceptions = *.exception.com, www.internal-site.org
#http-proxy-host = proxy2.some-domain-name.com
#http-proxy-port = 9000
# http-proxy-username = defaultusername

将

#http-proxy-host
#http-proxy-port

这两行前面的#号去掉，并将＝号右边的值分别改为你的代理服务器地址和端口号即可。

2、设置Eclipse/MyEclipse，确认SVN的客户端是SVNKit：

这样，就可以在Eclipse/MyEclipse中通过代理使用SVN了。

1. “系统兼容性”警告

在执行到系统检测那一步的时候有一个警告，提示是“系统兼容性错误”，因为是一个警告，当时也没有在意就继续安装了。但是安装的时候只有一个客户端可以选择，不能安装sql server服务。后来没办法，又重新回到刚才的警告，自己看了下“安装帮助”，原来企业版只能运行在win2k server和2003等系统上，不能运行在XP上。这一点跟之前的2000是类似的。所以本机只能安装标准版的了。

2. 性能计数器要求安装错误

提示的对话框如下：

查看了联机帮助，提示下面的解决办法（这个方法我试了之后不是很好，另外一个方法见下面）：

1 在 Microsoft Windows 2003 或 Windows XP 桌面上，依次单击“开始”、“运行”，然后在“打开”中键入 regedit.exe，再单击“确定”。在 Windows 2000 中，使用 regedt32.exe 启动注册表编辑器。

2 定位到以下注册表项：

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib]

“Last Counter”=dword:00000ed4 (5276)

“LastHelp”=dword:00000ed5 (5277)

3 上一步的“Last Counter”值 (5276) 必须与以下注册表项中“Perflib\009”的“Counter”项的最大值匹配，并且上一步的“Last Help”值 (5277) 必须与以下注册表项中“Perflib\009”的“Help”项的最大值匹配。

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\009]

注意 009 是英文中的一个示例。“Last Counter”和“Last Help”值是由 Windows 动态分配的；这两个值会因计算机的不同而不同。

4 如有必要，可修改“\Perflib”项中的“Last Counter”和“Last Help”值的值：在右侧窗格中，右键单击“Last Counter”或“Last Help”，单击“修改”，再单击“Base = “Decimal””，在“值数据”中设置值，再单击“确定”。如有必要，对另一个项重复以上过程，然后关闭注册表编辑器。

5 再次运行 SQL Server 安装程序。

可是按照上面的方法还是无法解决问题，后来网上查了下，找到一个解决的办法（见下面的参考资料）。不过其实没有作者介绍的那么复杂，只要在[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib] 找到04项下Count和Help中最大的项值（一般是最后一项）修改到Perflib目录下对应的“Laster Counter”项和“Laster Help”项就可以了。

3. SQL Server2005与SQL Server2000或SQL Server7.0共存的方法

因为都是在本机，安装2005的时候原来的SQL Server2000也不想删除，查了下资料这样是可以的，需要注意以下两点：

1) 在安装SQL2005的时候不要使用默认实例名称(SQL Server2000的实例名称是MSSQLSERVER)，手工输入一个自定义的不同于MSSQLSERVER的实例名称；

2) 如果和SQL Server2000安装到同一目录(例如C:\Program Files\Microsoft SQL Server)，那么在安装时不要选择安装SQL Server Management Studio，而是在安装之后到光盘的Tools\Setup目录下，运行SqlRun_Tools.msi安装。如果不小心已经安装上的话，在“添加/删除”里面删除掉SQL Server Management Studio然后在到光盘的Tools\Setup目录下，运行SqlRun_Tools.msi重新安装就可以了。

参考资料：

安装Ms SQL Server 2005 开发版时出现性能计数器要求安装错误的解决办法

http://submaie.cnblogs.com/archive/2006/02/07/326538.html

SQL Server2005与2000能否装在同一个系统？求确切答案

http://www.readbook8.com/dev/5701/4402802.htm

反复试了很多种方法依然是无效，后来从sqlYog官方网站上查到sqlYog从6.0开始每次生成的sql文件编码都是utf-8格式的，另外在操作数据之前都使用

将所有的环境都设置为utf8编码，你可以在sqlYog的查询窗口中使用

查看一下语言环境。sqlYog在查看数据的时候首先查看原来数据库设置的编码格式，然后将其转换为utf8格式的数据，最后输出出来；如果修改数据则相反。上次我在博文中提到使用sqlYog6.03可以直接查看gbk编码的数据，但是查看utf8格式的编码是乱码，我觉得这应该是sqlYog6.03版本中转换编码算法的一个bug，果然在最新发布的6.10rc版本中就修复了这个错误；另外一个就是根数据库默认设置的编码也有很大的关系，因为MySQL使用的默认编码是latin1，正是这样一个非常具有历史原因的设置成为了造成乱码的最直接的原因。这里可能有人会说不是sqlYog操作之前都已经将环境设置为utf8格式了吗？这个时候应该跟MySQL本身的编码没有任何关系了呀。sqlYog操作的时候是不会有关系，但是其他进程(比如php、java等)操作的时候呢？数据写入的时候已经出现乱码了，问题就出在这里。所以为了完全杜绝MySQL的乱码问题，建议将MySQL的默认编码设置为utf8格式。

因为wordpress数据库中的编码都是utf8格式的，我又使用的sqlYog6.03版本，所以无论查看还是备份utf8的数据都是乱码。最后只能是逐一从百度快照中将数据找出来添加到数据库中，因为我在wordpress中设置的remark规则跟时间和最后的数据id号有关系，为了不至于造成在百度中搜索出来的结果失效，所以首先先将原来数据库中的这些数据导入到新的数据中。当然这个时候wordpress已经升级成2.3了，呵呵(苦笑中…)

目前在2006年8月份之前的数据还没有恢复，将近有80条。我会在最近这段时间将他升级完成的。

参考资料：Which MySQL Character Sets are supported by SQLyog?

参考资料：hpMyAdmin 2.10.2 配置

一直是使用SQLyog来管理MySQL的，感觉他功能非常的强大，而且使用操作的时候非常的方便。但是一直以来SQLyog有个特别不爽的地方就是不支持Unicode，在查看数据库中的中文时会显示乱码，so如果直接用软件编辑保存的话显示到网页上面就是乱码了，完全没有使用SQL Server管理器那样的方便。

不过现在好了，今天无意间到SQLyog官方网站上面的时候，发现软件已经升级到6.x版本了，我所期待的支持中文的功能也实现了，爽啊~~~

1. 设置MySQL为Windows服务

在Windows下用mysqld-nt.exe可以注册为服务，即用mysqld-nt –install mysql
这会设置为mysqld-nt.exe为mysql服务，相关信息在命令行模式下查询mysqld-nt –verbose –help

2. 启动服务时出现“错误1067”的解决方法

参考手册中明确说明了这个问题：

These messages often occur when the MySQL base or data directories are installed in different locations than the default locations (C:\Program Files\MySQL\MySQL Server 5.0 and C:\Program Files\MySQL\MySQL Server 5.0\data, respectively).

上面的意思是在没有将MySQL安装到默认的目录下面的情况下启动Windows服务的时候就会出现上述提示，解决的办法就是指定MySQL跟目录以及数据库目录。在my.ini文件最后增加以下内容，然后将my.ini拷贝到windows目录下。

3. 初始帐号

用户名root，密码为空，所以说默认情况下的MySQL5是不安全的。进入之后立即修改root帐号密码，命令如下：

1. Integrated security 增强了安全连接，不过这个功能只支持 Windows 系统。我记得是需要拷贝一个dll文件

2. Client Failover, Database Mirroring support 支持 客户端失效倍援和数据库镜像功能
数据镜像功能其实是SQL Server2005的一个新功能，现在的JDBC驱动也支持了。关于这个功能更多可参考：http://www.microsoft.com/technet/prodtechnol/sql/2005/dbmirror.mspx
客户端失效倍援（不知道这个翻译是否准确）的描述是这样的：When connecting to a Sql Server 2005 Database that has a failover partner the JDBC v1.1 driver will cache failover information and retry to the failover partner on primary failure. Additionally you can use the new “failoverPartner” connection string keyword to handle initial connection failure scenarios.

3. 修复了以下上个版本里面的比较严重的bug（前面的数字是提交bug时候产生的序号，没有具体的含义）
<blockquote> <li>426389 Calling Statement.execute no longer causes an SQLException with the

message “sp_cursoropen/sp_cursorprepare: The statement parameter can

only be a single select or a single stored procedure‿ for UPDATE

WHERE queries when the selectMethod=cursor connection property is set.</li>

<li>436718 Calling PreparedStatement.execute no longer causes an SQLException

with the message “sp_cursoropen/sp_cursorprepare: The statement

parameter can only be a batch or a stored procedure with a single

select, without FOR BROWSE, COMPUTE BY, or variable assignments‿ for

INSERT INTO queries when the selectMethod=cursor connection property is set.</li>
<li>450639 The driver no longer throws an SQLException with the message “Server

failed to resume the transaction, desc: 4600000001.‿ when configuring

SQL Server 2005 as the JBoss JMS message store.</li>
<li>435796 Executing SQL WRITETEXT statements no longer throws an SQLException

with the message “No TDS_RET_STATUS was found for the stored procedure

output parameters.‿</li>
<li>424295 DatabaseMetaData.getMaxConnections no longer throws an SQLException with

the message “The configuration option ‘user connections’ does not exist,

or it may be an advanced option‿ for SQL Server 2005 servers.</li>
<li>433394 Calling Statement.executeBatch after setting a BLOB value no longer throws

an SQLException with the message “The conversion from BLOB to BINARY is unsupported.‿</li>
<li>435448 The driver no longer throws an SQLException with the message

“com.microsoft.sqlserver.jdbc.SQLServerException: Incorrect syntax near ‘-’‿

when sending a BigDecimal prepared statement parameter value to the server

with the 5.0 JRE.</li></blockquote>
参考资料：
JDBC 2005 v1.1 is now available.

另外，每一个数据库用户对应于一个系统登陆帐号，并且每一个架构只能赋予一个用户。所以直接删除用户的架构是不可以的，可以这样：首先创建一个新的登陆名，然后将需要删除的架构赋予这个新用户。这样就可以删除之前的用户了。

参考资料：
SQL 2005 应用手记
http://silverfox.mynew.ws/blog/index.php?/archives/111-SQL-2005.html

需要说明几点：
1. 上面的SQL命令需要按照顺序执行；
2. 执行上面的命令通常比直接使用右键菜单中的“收缩”命令要快很多

参考资料：
SQL SERVER 数据库日志已满，如何收缩数据库日志
http://blog.csdn.net/faintbear/archive/2005/02/06/283316.aspx
如何收缩数据库日志
http://www.cndiy8.com/data/web5701/20050228/20050228__3794589.html

Announcing the June 2006 Community Tech Preview of the JDBC 2005 driver:
http://www.microsoft.com/downloads/details.aspx?familyid=f914793a-6fb…

This preview contains all the changes of CTP 1 including Integrated
Security, it includes rollup fixes for all the QFEs we have shipped to date
and we have addressed most customer issues filed through the product
feedback center.

To round it off we have also added a brand new feature: Client Failover. As
far as I know this is the first JDBC driver to take advantage of Sql Server
2005 Database Mirroring. This feature has been fully documented for this
CTP, we could really use feedback on both the functionality and the docs.

For a complete change list take a look at the release.txt file that ships
with the package, for the first time we are providing comprehensive
information on the work we have done since v1.0, let us know if this is
helpful information.

下载地址：http://msdn.microsoft.com/data/ref/jdbc/

http://code.google.com/p/jquery-api-zh-cn/downloads/list

本来更早出来的，结果半路又杀出1.4.1，而且发现bind、live还有ajax等方法有大量更新，所以重新翻译这三个方法，消耗了大把时间。所以今天才发出来。

还有个html版的http://jquery-api-zh-cn.googlecode.com/svn/trunk/index.html

似乎这个不怎么更新了 大家还是用chm的吧 也比较方便

内容：
这里，用的xfire1.2.6和Spring 2.0，开发工具用的MyEclispe，虽然MyEclipse自带了开发xfire的插件，但为了不依赖开发工具，所以以下为手动创建。
Xfire 可以很好的和Spring 集成，下面分两部分介绍
纯Xfire 的web service
1.1、先建一个web 项目，打开下载到的xfire包，将lib下的所有 Jar包和modules目录下的所有Jar包拷到web 项目的WEB-INF/lib目录下。
1.2、修改web.xml文件，添加如下内容，以支持xfire：

<servlet>
<servlet-name>XFireServlet</servlet-name>
<servlet-class>org.codehaus.xfire.transport.http.XFireConfigurableServlet
</servlet-class>
<load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>XFireServlet</servlet-name>
<url-pattern>/services/*</url-pattern>
</servlet-mapping>

这样，便可以通过http://localhost:8080/projectName/services/ 路径来访问所有发布的web services了。
1.3、在项目下的WEB-INF目录下建立META-INF/xfire/这个目录，在此目录下建立services.xml文件，这个文件用来添写我的要发布的web services。文件内容如下所示：

<beans>
<service  xmlns=”http://xfire.codehaus.org/config/1.0″>
<name>HelloService</name>
<serviceClass>com.services.HelloService</serviceClass>  <implementationClass>com.services.HelloServiceImpl</implementationClass>
</service>
</beans>
文件的内容如下：
：发布一个web service；
：发布web service的名称；
：提供服务的接口类；
：实现服务接口类的具体类。

注：这里用的Spring 2.0，如果是用xfire 自带的Spring1.2.6，应该将  xmlns=”http://xfire.codehaus.org/config/1.0″ 放到里去定义。
1.4、下面，将这个web 项目，发布到tomcat下，便可以使用

http://localhost:8080/xfire/services/HelloService?wsdl

来调用这个web service了。
于Spring 集成的Xfire 开发web services，这里用的是spring 2.0，如果是spring2.5，需要将spring-webmvc.jar添加进来。

下面说与Spring 集成的Xfire开发步骤
Spring 与xfire 有三种结合方式，下面以直接与spring集成的方法说明。
（通过Spring的org.springframework.web.servlet.DispatcherServlet）。
2.1、将xfire与spring的JAR包放到web 项目的classPath
2.2、修改web.xml，使其支持Spring 与xfire，添加如下内容：

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/conf/applicationContext.xml
classpath:org/codehaus/xfire/spring/xfire.xml
</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<servlet>
<servlet-name>xfire</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<load-on-startup>0</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>xfire</servlet-name>
<url-pattern>/service/*</url-pattern>
</servlet-mapping>

2.3、根据web.xml的内容，创建Spring的配置文件：applicationContext.xml
在本例中，将此文件放在WEB-INF/conf目录下。内容如下：

<?xml version=”1.0″ encoding=”UTF-8″?>
<!DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN” “http://www.springframework.org/dtd/spring-beans.dtd”>
<beans>
<bean id=”helloBean” />
</beans>

这里，定义了一个bean,这里用的是web services接口的实现类。
2.4、在WEB-INF下创建xfire-servlet.xml文件，这里的xfire是org.springframework.web.servlet.DispatcherServlet这个servlet的名称，应该根据自己的进行修改
内容如下：

<?xml version=”1.0″ encoding=”UTF-8″?>
<!DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN” “http://www.springframework.org/dtd/spring-beans.dtd”>
<beans>
<!– 在这写上这名，这样就可以用applicationContext.xml里定义的Bean –>
<import resource=”classpath:org/codehaus/xfire/spring/xfire.xml” />

<!– 这是定义URL映射 –>
<bean>
<property name=”urlMap”>
<map>
<!– 在这写每一个Web Service的URL映射 –>
<entry key=”/HelloService”> //URL，访问地址
<ref bean=”hello” />
</entry>
</map>
</property>
</bean>

<!– 定义一个基础Service,以下的Service引用它 –>
<bean id=”baseWebService”

lazy-init=”false” abstract=”true”>
<!– 引用xfire.xml中定义的工厂 –>
<property name=”serviceFactory” ref=”xfire.serviceFactory” />
<!– 引用xfire.xml中的xfire实例 xfire是web.xml配置的DispatcherServlet的名称–>
<property name=”xfire” ref=”xfire” />
</bean>

<!– 定义一个Hello　的WebService，这里的serviceClass是接口 –>
<bean id=”hello” parent=”baseWebService”>
<property name=”serviceBean”>
<ref bean=”helloBean” />
</property>
<property name=”serviceClass”>
<value>com.service.HelloService</value>
</property>
</bean>
</beans>

这样便生成一个web Service，可以通过域名来访问，并编写客户端代码了。

另一种方式，使用xfire自带的org.codehaus.xfire.spring.XFireSpringServlet这个类进行设置。
方法如下：
修改web.xml，添加如下内容：

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>

<!–XFire 配置  –>
<servlet>
<servlet-name>XFireServlet</servlet-name>
<servlet-class>
org.codehaus.xfire.spring.XFireSpringServlet
</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>XFireServlet</servlet-name>
<url-pattern>/service/*</url-pattern>
</servlet-mapping>

这样，便不必使用xfire-servlet.xml文件，直接在applicationContext.xml里添加Web Service的Bean就可以了。applicationContext.xml代码如下：

<?xml version=”1.0″ encoding=”UTF-8″?>
<!DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN” “http://www.springframework.org/dtd/spring-beans.dtd”>
<beans>

<!– web service 配置 –>
<import resource=”classpath:org/codehaus/xfire/spring/xfire.xml” />

<bean id=”HelloServiceImpl”
/>

<bean id=”HelloService”
>
<property name=”xfire” ref=”xfire” />
<property name=”serviceBean” ref=”HelloServiceImpl” />
<!– WebService的实现类bean –>
<property name=”serviceClass”
value=”com.service.service.HelloService” />
</bean>
</beans>

但个Web Service是没有任何安全性可言的，任何拿到WSDL的人都可以轻松地构造客户端程序访问我们的Web Service服务。

翻译： zilong3927  原文地址： http://docs.codehaus.org/display/XFIRE/Mapping+collections

调用 Web Services 时，经常需要返回集合（ collection ）作为结果，或者接受 collection 型的参数。 SOAP 本身就支持这一点。

但是这一机制的问题在于， java 语言的 collections 是无类型的（ untyped ） . 因此，如果要在 Java 1.4 当中支持 collections ， 就需要做一些额外的工作。

Java 5 & 范型（ Generics ）

首先而且是推荐的做法是在 JDK5 当中使用范型（ generics ）。范型能够使你在代码当中为你的 collections 指定类型信息， 从而允许 xfire 自动地推导出 collection 类型，生成正确的 wsdl 等等。

下面示例了如何写这样的一个方法：

public    Collection <   String   >  getValuesForIds(Collection <   Integer   > );

Java 1.4 & 集合（ Collections ）

有些情况下并不总能够使用范型（ generics ） . 例如，如果你的部署环境使用 JDK 1.4 ， 或者你想暴露一些遗留的服务，而同时又不打算修改任何代码也不打算进行移植。

对于这样的一些情况而言， 你需要生成一个 xml 映射文件，来指定方法和它们对应的集合类型（ collection types ） .

这个 xml 文件的名字必须是 <className>.aegis.xml ， 其中 className 是你的服务（ service ）的接口类（ unqualified class ）的名字。

下面最好通过一个例子来展示这个 xml 文件的格式。 我们想要展现的服务有这样的一个接口 :

public   interface  MyService1{
String getFoo();
Collection getCollection();
void  setList(  int  id ， java.util.List);
}

既然代码中的 collections 没有指定类型， 我们剧需要生成一个 xml 文件来指定所需要的类型。 这个文件的路径应该和 MyService1.class 在同一个包（ package ）当中， 并且它的名字应该是 MyService1.aegis.xml

对于这个接口来说，一个最简单的映射文件如下 :
< mappings >
< mapping >
< method  name = “getCollection”   >
< return-type  componentType = “java.lang.String”   />
</ method >
< method  name = “setList”   >
< parameter  index = “1″  componentType = “java.lang.String”   />
</ method >
</ mapping >
</ mappings >

注意这个映射文件确切地指定了所需要的信息，不包含任何冗余。 例如， getFoo 方法没有被指定，这是由于它没有包含任何 collections ，因此能够在没有任何映射信息的情况下暴露给使用者。

其次， setCollection 方法没有指定索引为 0 的参数。 这是由于该参数类型为 int ，因此不需要任何映射

如果我们有多个方法，都匹配指定的映射又该怎么办 ? 这种情况下， 映射就对所有匹配的方法均有效。

所以，如果在我们的接口中增加以下的方法：

void  setList( int id ，java.util.List， boolean persist);

那么现在我们的映射定义对于两个 setList 方法都有作用。这种情况下， 我们不必为额外的参数（译者注：此处指 boolean persist ）指定两次映射 . 映射文件就指定了所有那些第二个参数为 List 的方法，并假定 List 中包含的都是 strings 。

如果我们想让那个具有 3 个参数的方法，其中的 list 不包含 Strings ， 而是实际上包含 Dates? 这种情况下， 就需要一个更确切的映射来覆盖（ override ）原先那个更一般的， 所以我们的映射文件需要添加下面这个定义 :
< method  name =  “setList”    >
< parameter  index = “1″  componentType = “java.lang.String”   />
< parameter  index = “2″  class = “boolean”   />
</ method >

注意一下类型属性。 现在这个映射将对所有那些第二个参数为 List ，第三个参数为 boolean 型的方法适用。 在我们的接口当中，这个映射唯一地确定了一个特定的方法，使用这个映射就能够解释方法当中的 List 参数。

在优先顺序方面， 更确切的映射总是优先于更一般的。

让我们考虑下面这个复杂一些的例子 :

public      interface    MyService2
{
Collection getCollection();  // method 1
Collection getCollection(  int  id);  // method 2
Collection getCollection( String id);  // method 3
Collection getCollectionForValues(  int  value ， Collection c);  // method 4
Collection getCollectionForValues( String id ， Collection c);  // method 5
}

映射文件的内容为 :
< mappings >
< mapping >
<!–  mapping 1  –>
< method  name = “getCollection”   >
< return-type  componentType = “java.lang.Double”   />
</ method >
<!–  mapping 2  –>
< method  name = “getCollection”   >
< return-type  componentType = “java.lang.Float”   />
< parameter  index = “0″  class = “int”   />
</ method >
<!–  mapping 3  –>
< method  name = “getCollectionForValues”   >
< return-type  componentType = “java.math.BigDecimal”   />
</ method >
<!–  mapping 4  –>
< method  name = “getCollectionForValues”   >
< parameter  index = “0″  class = “java.lang.String”   />
< parameter  index = “1″  componentType = “java.util.Date”   />
</ method >
<!–  mapping 5  –>
< method  name = “getCollectionForValues”   >
< return-type  componentType = “java.util.Calendar”   />
< parameter  index = “0″  class = “int”   />
< parameter  index = “1″  componentType = “java.lang.Bit”   />
</ method >
</ mapping >
</ mappings >

这个文件的格式是不需要做过多解释的。但有几点还是需要加以说明。

先来看一下第一个映射 (mapping 1) 。 这个映射指定了所有 getCollection 方法所返回的 collections contain 均包含 java.lang.Doubles 。 如果没有指定其他的 getCollection 映射， 那么这个映射将对方法 1 ， 2 ， 3 都适用。

但是，第二个映射更加明确地指定了它所适用的方法。即如果 getCollection 方法的第一个参数是 int 型，那么该方法所返回的 collection 包含的是 Float 型。 由于这条规则更加明确，它将为方法 2 覆盖掉第一个映射，这是满足映射约束标准的。

使用以上的规则，不难推导出方法 4 和方法 5 返回的 collections 结果的组件类型（ component types ）。

Collections on Javabeans

对于使用 collections 的 java beans 来说，语法也是类似的。 例如，比方说我们有一个 Company bean ，包含了一个 List ， 其中的对象是 employees:

public   class  Company
{
private  Collection employees;
Collection getEmployees() {  return  employees; }
public   void  setEmployees(Collection employees) {  this  .employees  =  employees };
}

除了可以使用 <method> & <parameter> 元素外， 也可以使用 <property> 元素 :
< mappings >
< mapping >
< property  componentType = “org.codehaus.xfire.Employee”   />
</ mapping >
</ mappings >

Handling Maps

Java Maps 并不能很好地映射到 XML Schema (no pun intended) ，因为 XML Schema 中没有 Map 的概念，客户端也是这样， Maps 被转换成 {key ， value} 元组的集合。 除了要提供 value 的类型以外，你还必须为 Aegis 提供 key 的类型 :

public     class  GiftService {
Map getGiftList() {  /*  returns a map of NiceChild => Present  */  }
}

映射文件应该像下面这样 :
< mappings >
< mapping >
< method  name = “getGiftList”   >
< return-type  keyType = “org.codehaus.xfire.NiceChild”  componentType = “org.codehaus.xfire.Present”   >
</ method >
</ mapping >
</ mappings >

这将生成下面的类型 :
< xsd:complexType  name =  “NiceChild2PresentMap”    >
< xsd:sequence >
< xsd:element  name = “entry”  minOccurs = “0″  maxOccurs = “unbounded”   >
< xsd:complexType >
< xsd:sequence >
< xsd:element  name = “key”  type = “ns1:NiceChild”  minOccurs = “0″  maxOccurs = “1″   />
< xsd:element  name = “value”  type = “ns1:Present”  minOccurs = “0″  maxOccurs = “1″   />
</ xsd:sequence >
</ xsd:complexType >
</ xsd:element >
</ xsd:sequence >
</ xsd:complexType >

Collections of Collections of Collections of….

在某些情况下，你可能想要传递 Collections of Collections 。比方说你有一个返回 List of a List of Doubles 的服务 ( 不要问为什么你要做这样一件事情 …):

public   class  ListService
{
public  List getListOfListOfDoubles
{
List l  =   new  ArrayList();
List doubles  =   new  ArrayList();
doubles.add(  new  Double ( 1.0 ));
l.add(doubles);
return  l;
}
}

要处理这种情况，我们需要引进一个新的 <component> 元素。 下面是一个很好的例子 :
< mappings >
< mapping >
< method  name = “getListofListofDoubles”   >
< return-type  componentType = “#someDoubles”   />
</ method >
< component  name = “someDoubles”  class = “java.util.List”  componentType = “java.lang.Double”   />
</ mapping >
</ mappings >

正像你在这里所看到的，返回类型的 componentType 是一个指向 <component> 的引用，而不是一个类。组件类型 “#someDoubles” 引用到名字为 “someDoubles” 的 <component> 。

Aegis 将会自动给这些 collections 命名为 ArrayOfDouble 和 ArrayOfArrayOfDouble 。 你也可以改变这些名字。 要设置你自己的名字， 提供一个 “typeName” 属性即可 :
< mappings >
< mapping >
< method  name = “getListofListofDoubles”   >
< return-type  componentType = “#someDoubles”  typeName = “LotsOfDoubles”   />
</ method >
< component  name = “someDoubles”  class = “java.util.List”  typeName = “SomeDoubles”  componentType = “java.lang.Double”   />
</ mapping >
</ mappings >

package com.kuaff.xfire.samples;
public class MathService
{
public long add( int p1, int p2)
{
return p1 + p2;
}
}

在 src 目录下创建 META-INF/xfire 目录，然后在 META-INF/xfire 目录下创建 services.xml 文件，文件内容为：
<beans xmlns=”http://xfire.codehaus.org/config/1.0″>
<service>
<name>MathService</name>
<namespace>http://www.kuaff.com/xfire/samples/MathService</namespace>
<serviceClass>com.kuaff.xfire.samples.MathService</serviceClass>
</service>
</beans>
这个文档定义了你要发布的 web 服务，这个定义了一个名为 MathService 的服务，服务类为 com.kuaff.xfire.samples.MathService 。
这样我们的一个简单的 web 服务就开发完成了，下面就要把它发布出去。
将工程 bin 目录下的所有的文件复制到第一节中配置的 tomcat/webapps/xfire/WEB-INF/classes 文件夹下，启动 tomcat ，你就可以检查这个 web 服务是否发布成功了。
打开浏览器，在浏览器地址栏中输入 http://localhost:8080/xfire/services/ ，正常情况下应该浏览器应该显示类似下面的页面。

Available Services:

• MessageHistoryService [wsdl]

注意：请在浏览器中输入 http://localhost:8080/xfire/services/ 而不是 http://localhost:8080/xfire/services ，虽然两者显示的页面相同，但是点击页面上的链接，后者的链接会出错，因为后者后面少加了一个“ / ”。点击 [wsdl] 链接，可以查看这个 web 服务的 wsdl 文档。

如果在你的机器上的显示如上面所示，则说明你的这个 web 服务发布成功，可以正常提供基于 http 的 web 服务。

下面一个问题就是如何开发一个 Client ，来消费（使用）这个 web 服务。

XFire 、 Axis 、 asp.net 以及其它的一些商业产品都提供了根据 wsdl 文档创建客户端代码的工具。这里采用 Xfire 提供的 wsgen 工具来创建客户端的访问代码。

Wsgen 是 xfire 提供的一个 ant task ， task 的申明如下：

<taskdef name= “wsgen” classname= “org.codehaus.xfire.gen.WsGenTask” classpathref= “xfire 的 jar 路径 ” />

这样，就可以在 build.xml 文件中使用这个 task ：

<wsgen outputDirectory= “client” wsdl= “MathService.wsdl” package= “com.kuaff.xfire.samples” />

outputDirectory 属性定义创建的代码所在的文件夹， wsdl 是 web 服务的 wsdl 文件， package 代表创建的代码的 packege 。还可以通过 binding 属性制定 bind 类型： jaxb 或者是 xmlbeans ，

这样，就会在 client 文件夹下创建多个 java 文件，这些文件提供了访问 web 服务的方法。
在这里声明一点，创建的代码大量的使用了 java 注释，这个 JSE5 中提供的新特性，所以你需要使用 JSE5 编译， Eclipse 也必须要 3.1 以上的版本。
这段 ant 脚本将创建三个文件： MathServicePortType 、 MathServiceImpl 和 MathServiceClient 。 MathServicePortType 是这个 web 服务的客户端接口存根、 MathServiceImpl 实现了这个接口。 MathServiceClient 封装了访问这个 web 服务的方法。
最后，你可以创建一个单元测试类，用来测试这个客户端类。这个类的内容如下：
package com.kuaff.xfire.samples;
import junit.framework.TestCase;
public class MathServiceClientTest extends TestCase
{
public void testAdd()
{
MathServiceClient client = new MathServiceClient();
MathServicePortType ms = client.getMathServiceHttpPort();
long result = ms.add(10, 20);
assertEquals (result, 30);
}
}

相 对于Axis来说，目前XFire相对受欢迎，加上其提供了和Spring集成的支持，在目前的Web Service开源社区拥有众多的追随者。并且因为XFire为Spring提供的支持，使得我们可以很容易在Spring中使用XFire构建Web Service应用。

XFire 与Axis2相比具有如下特征：

l         支持一系列Web Service的新标准–JSR181、WSDL2.0 、JAXB2、WS-Security等；

l         使用Stax解释XML,性能有了质的提高。XFire采用Woodstox 作Stax实现；

l         容易上手，可以方便快速地从pojo发布服务；

l         支持Spring、Pico、Plexus、Loom等容器；

l         灵活的Binding机制，包括默认的Aegis,xmlbeans,jaxb2,castor；

l         高性能的SOAP 栈设计；

l         支持Spring、Pico、Plexus、Loom等容器。

XFire 与Axis1性能的比较如下：

l         XFire 比Axis1.3快2-6倍；

l         XFire 的响应时间是Axis1.3的1/2到1/5。

XFire 在WebService框架中开始较晚，它从现有的框架中借鉴了许多优秀的理念，力争将Web Service的应用开发难度降到最低。此外，还提供了各种绑定技术、支持多种传输协议，对WebService体系中许多新的规范提供了支持。

下面让我们来看一个XFire于Spring集成的helloWorld的简单例子。

一．实现的功能和特点

本例具有如下功能和特点：

1）  基于J2EE平台的Web Service服务；

2）  开发方便，配置简单；

3）  与spring无缝集成。

XFire 是完全基于流数据处理进行工作的系统，这意味着XFire不是将整个SOAP文档缓存在内存中，而是以管道的方式接收SOAP流数据。这种工作方式的转变带来了可观的性能回报，同时节省了内存的占用。

XFire 从 管道中接收一个SOAP请求到返回一个SOAP响应，会经历一系列的阶段。在管道调用的任何一个阶段，XFire都可以添加一些额外的Handler，在 对消息进行加工处理后再传入到下一个阶段中。在SOAP请求消息对Web Service发起真正调用之前，分别会经过传输、预转发、转发、策略实施、用户信息处理、预调用、服务调用等阶段。

二．开发环境

笔者的开发环境描述如下：

1）  jdk: 1.5 版本；

2）  Tomcat ：5.5.20；

3）  MyEclipse: 5.1.1 GA 。

三．开发步骤

1. 工程与环境的建立

在 MyEclipse中新建Web工程，名为webservice_helloworld。选择该工程后，点击右键选择MyEclipse->Add Web Service Capabilities，弹出Add Web Service Capabilities对话框，点击“Next”，弹出Project Library Configuration对话框，默认选择Core Libraries，点击“Finish”按钮，完成XFire核心包的添加。为了后续的客户端的测试，还需读者加入commons- httpclient.jar包到WEB-INF/lib下。

部署后可看到此时WEB-INF/lib的jar包列表如下：

activation-1.1.jar 、 commons-beanutils-1.7.0.jar、commons-codec-1.3.jar、commons- httpclient.jar、commons-logging-1.0.4.jar、jaxen-1.1-beta-9.jar、jaxws-api- 2.0.jar、jdom-1.0.jar、jsr173_api-1.0.jar、mail-1.4.jar、saaj-api-1.3.jar、 saaj-impl-1.3.jar、spring-1.2.6.jar、stax-api-1.0.1.jar、wsdl4j-1.5.2.jar、 wstx-asl-3.0.1.jar、xbean-2.1.0.jar、xbean-spring-2.5.jar、xfire-aegis- 1.2.2.jar、xfire-annotations-1.2.2.jar、xfire-core-1.2.2.jar、xfire- java5-1.2.2.jar、xfire-jaxws-1.2.2.jar、xfire-jsr181-api-1.0-M1.jar、xfire- spring-1.2.2.jar、XmlSchema-1.1.jar

为了后续的开发和测试，在src目录下分别建立test和webservice目录，分别用于存放测试文件和webservice的相关类。

2 ．Web Service实现的编写

在本例中，我们只是做一个helloWorld的简单例子。Web Service服务端提供一个根据输入的名字信息回复相应的helloWorld信息的。例如，当名字为“阿蜜果”时，恢复信息为“hello，阿蜜果”。下面让我们一步一步来开始进行编码。

1） web.xml 的配置

一 般情况下，我们通过HTTP作为Web Service的传输协议，这样我们只需启动一个Web服务器(如Tomcat，在本例中使用的是Tomcat5.5.20)，这样客户端就可以通过 HTTP访问到Web Service服务。为了集成Spring容器，XFire专门提供一个XFireSpringServlet，我们可以在web.xml中配置该 Servlet，将Spring容器中定义的Web Service在某个URI下发布。

为了能正确使用XFire，需在web.xml中进行相应配置，在该文件中配置XFire的 servlet 和 servlet-mapping 。同时因为本实例需要将 XFire 集成到 Spring 中，因而需要在 web.xml 文件中加载 Spring 的相应配置文件。在本实例中，我们首先在 WEB-INF 下建立两个配置 Spring 配置文件，一个为 applicationContext.xml ，该文件用来定义本工程的 bean ，一个为 xfire-servlet.xml ，用来配置 XFire 的相关 bean 。修改后的 web.xml 的内容如下所示：
<? xml version=”1.0″ encoding=”UTF-8″ ?>
< web-app  xmlns =”http://java.sun.com/xml/ns/j2ee”  xmlns:xsi =”http://www.w3.org/2001/XMLSchema-instance”  version =”2.4″  xsi:schemaLocation =”http://java.sun.com/xml/ns/j2ee   http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd” >
< display-name > XFireService </ display-name >
<!–  begin Spring配置  –>
< context-param >
< param-name > contextConfigLocation </ param-name >
< param-value > /WEB-INF/applicationContext.xml,/WEB-INF/xfire-servlet.xml </ param-value >
</ context-param >
< listener >
< listener-class >  org.springframework.web.context.ContextLoaderListener
</ listener-class >
</ listener >
< listener >
< listener-class >      org.springframework.web.util.IntrospectorCleanupListener
</ listener-class >
</ listener >
<!–  end Spring配置  –>

<!–  begin XFire 配置  –>
< servlet >
< servlet-name > xfire </ servlet-name >
< servlet-class > org.springframework.web.servlet.DispatcherServlet </ servlet-class >
</ servlet >
< servlet-mapping >
< servlet-name > xfire </ servlet-name >
< url-pattern > *.ws </ url-pattern >
</ servlet-mapping >
< servlet >
<!–  配合Spring容器中XFire一起工作的Servlet –>
< servlet-name > xfireServlet </ servlet-name >
< servlet-class > org.codehaus.xfire.spring.XFireSpringServlet </ servlet-class >
</ servlet >
< servlet-mapping >
< servlet-name > xfireServlet </ servlet-name >
<!–  在这个URI下开放Web Service服务  –>
< url-pattern > /service/* </ url-pattern >
</ servlet-mapping >
<!–  end XFire 配置  –>
</ web-app >

2） Web Service 的接口类 HelloWorld.java 和对应实现类 HelloWorldImpl.java

为了用 Web Service 完成 HelloWorld 功能，我们首先在 src/webservice 目录下建立接口类 HelloWold.java 。它仅包含一个 sayHelloWorld(String name) 的方法，其详细内容如下：
package  webservice;

/** */ /**
*HelloWorld的接口类.
*/
public interface HelloWorld  {
/** */ /**
*对名字为name的人打招呼.
*@paramname名字
*@return返回打招呼的字符串
*/
String sayHelloWorld(String name);
}
我们还需要建立一个对应的实现类，来实现sayHelloWorld的功能，该实现类即为HelloWorldImpl.java。该类的详细内容如下：
package  webservice;
/** */ /**
*HelloWorld的实现类.
*/
public class HelloWorldImpl  implements  HelloWorld  {
public  String sayHelloWorld(String name)  {
String helloWorld  =   ” hello, “   +  name;
return  helloWorld;
}
}

3） Spring 配置文件 applicationContext.xml 和 xfire-servlet.xml 的配置

首先我们在 applicationContext.xml 文件中配置对应的 bean —— HelloWorldBean ，该 xml 文件的内容如下：
<? xml version=”1.0″ encoding=”UTF-8″ ?>
<! DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN”
“http://www.springframework.org/dtd/spring-beans.dtd” >
< beans >
< bean  id =”HelloWorldBean”  class =”webservice.HelloWorldImpl” />
</ beans >
这个配置文件很简单，在此不详述。

XFire 为 Spring提供了方便易用的导出器XFireExporter，借助该导出器的支持，我们可以在Spring容器中将一个POJO导出为Web Service。HelloWorld是业务服务类，在此拥有一个sayHelloWorld的方法，我们希望将此方法开放为Web Service。在实际应用中，如果某个类具有众多的方法，而其中的某些方法不需要开放为Web Service的情况下，我们可以定义一个窄接口，该接口中只需定义那些开放为Web Service的业务方法。

将一个业务类所有需要开放为Web Service的方法通过一个窄接口来描述是值得推荐的作法，这让Web Service的接口显得很“干净”。其次，XFire的导出器也需要服务接口的支持，因为它采用基于接口的动态代理技术。

窄接口中的方法在真实的系统中可能需要引用其它的业务类或DAO获取数据库中的真实数据，为了简化实例，我们在此简化了实例。

下面让我们看看在xfire-servlet.xml文件中导出器的设置，该文件内容如下：
<? xml version=”1.0″ encoding=”UTF-8″ ?>
<! DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN”
“http://www.springframework.org/dtd/spring-beans.dtd” >
< beans >
<!–  引入XFire预配置信息  –>
< import  resource =”classpath:org/codehaus/xfire/spring/xfire.xml”   />
<! —定义访问的url– >
< bean  class =”org.springframework.web.servlet.handler.SimpleUrlHandlerMapping” >
< property  name =”urlMap” >
< map >
< entry  key =”/HelloWorldService.ws” >
< ref  bean =”HelloWorldService”   />
</ entry >
</ map >
</ property >
</ bean >

<!–  使用XFire导出器  –>
< bean  id =”baseWebService”  class =”org.codehaus.xfire.spring.remoting.XFireExporter”  lazy-init =”false”  abstract =”true” >
<!–  引用xfire.xml中定义的工厂  –>
< property  name =”serviceFactory”  ref =”xfire.serviceFactory”   />
<!–  引用xfire.xml中的xfire实例  –>
< property  name =”xfire”  ref =”xfire”   />
</ bean >
< bean  id =”HelloWorldService”  parent =”baseWebService” >
<!–  业务服务bean  –>
< property  name =”serviceBean”  ref =”HelloWorldBean”   />
<!–  业务服务bean的窄接口类  –>
< property  name =”serviceClass”  value =”webservice.HelloWorld”   />
</ bean >
</ beans >

在上面的配置中，我们可以看到，在该配置文件中引入了xfire.xml这个Spring配置文件。它是在XFire核心JAR包中拥有一个预定义的 Spring配置文件，它定义了XFire在Spring中必须用到的一些Bean和资源，需要引入这个预定义的配置文件。从该配置文件中可以看出，我们通过XFireExporter将业务类导出为Web Service，对于任何导出器，我们都需要引入XFire环境，即serviceFactory 和 xfire ，这是标准的配置。 ServiceFactory 是XFire的核心类，它可以将一个POJO生成为一个Web Service。

在本实例中，我们通过定义一个baseWebService，其余的webService配置都将该bean作为父bean，这样可以简化Spring的配置，不需要多次引入serviceFactory和xfire。

3. Web Service 的测试

在上一步操作完成之后，我们的这个简单的 Web Service 已经编写完毕，下面让我们来看看自己的劳动成果吧。

在浏览器中输入地址： http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl ，我们可以看到 HelloWorldService 对应的 WSDL 信息， 阅读这个WSDL文档，我们可以知道HelloWorld的sayHelloWorld方法已经被成功地发布为Web Service了。只要拿到这个WSDL就可以开发相应的客户端调用程序了。

XFire 为访问服务端Web Service提供了各种方便的方式：我们一般根据服务地址和窄接口类创建客户调用程序。

在不能获得服务窄接口类的情况下，XFire允许我们通过WSDL文件生成客户端调用程序，通过指定服务接口的方式调用服务。

1） 通过WSDL文件生成客户端调用程序

首先我们通过 http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl 我们可以获得 WSDL 文件 HelloWorldService.wsdl ，并将其放在 src 目录下面，接着我们通过程序访问该 WSDL 文件，并调用需测试的方法。此时测试类 WebServiceClientTest.java 的内容如下所示：
package  test;

import  org.codehaus.xfire.client.Client;
import  org.springframework.core.io.ClassPathResource;
import  org.springframework.core.io.Resource;
import  webservice.HelloWorld;

/** */ /**
*Copyright2007GuangZhouAmigo.
*Allrightreserved.
*HelloWorld的webservice的测试类.
* @author <a href=”mailto:xiexingxing1121@126.com”>AmigoXie</a>
*@version1.0
*Creationdate:2007-9-16-下午05:36:05
*/
public class WebServiceClientTest  {
HelloWorld helloWorld  =   null ;

public static void main(String[] args)  throws  Exception  {
WebServiceClientTest test  =   new  WebServiceClientTest();
test.testClient();
}

public void testClient()  throws  Exception  {
String wsdl  =   ” HelloWorldService.wsdl ” ;  // 对应的WSDL文件
Resource resource  =   new  ClassPathResource(wsdl);
Client client  =   new  Client(resource.getInputStream(),  null );  // 根据WSDL创建客户实例

Object[] objArray  =   new  Object[ 1 ];
objArray[ 0 ]  =   ” 阿蜜果 ” ;
// 调用特定的Web Service方法
Object[] results  =  client.invoke( ” sayHelloWorld ” , objArray);
System.out.println( ” result:  “   +  results[ 0 ]);
}
}

运行该类，可得到如下输出结果：

result: hello, 阿蜜果

可看出运行结果正确。

2 ）根据服务地址创建客户端调用程序

接着让我们来看一个根据服务地址创建客户端调用程序的例子。我们可以通过测试类来测试Web Service的正确性，下面让我们来看一个简单的测试类，首先我们在src/test目录建立 WebServiceClientTest.java 文件，并在 src 目录下建立客户端调用的 Spring 配置文件 client.xml 。在 client.xml 配置文件中我们定义了一个 testWebService 的 bean ，该 bean 访问 wsdlDocumentUrl 为 http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl 的 WSDL 。该 xml 文件的详细内容如下：
<? xml version=”1.0″ encoding=”UTF-8″ ?>
<! DOCTYPE beans PUBLIC “-//SPRING//DTD BEAN//EN”
“http://www.springframework.org/dtd/spring-beans.dtd” >
< beans >
< bean  id =”testWebService”  class =”org.codehaus.xfire.spring.remoting.XFireClientFactoryBean” >
< property  name =”serviceClass” >
< value > webservice.HelloWorld </ value >
</ property >
< property  name =”wsdlDocumentUrl” >
< value > http://localhost:8080/webservice_helloworld/HelloWorldService.ws?wsdl </ value >
</ property >
</ bean >
</ beans >

在 WebServiceClientTest.java 文件中获得 HelloWorld ，并调用它的 sayHelloWorld 方法来完成测试，该类的详细内容如下所示：
package  test;

import  org.springframework.context.ApplicationContext;
import  org.springframework.context.support.ClassPathXmlApplicationContext;
import  webservice.HelloWorld;

/** */ /**
*HelloWorld的webservice的测试类.
*/
public class WebServiceClientTest  {
HelloWorld helloWorld  =   null ;

public static void main(String[] args)  {
WebServiceClientTest test  =   new  WebServiceClientTest();
test.testClient();
}

public void testClient()  {
ApplicationContext ctx  =   new  ClassPathXmlApplicationContext(
” client.xml ” );
helloWorld  =  (HelloWorld) ctx.getBean( ” testWebService ” );
System.out.println(helloWorld.sayHelloWorld( ” 阿蜜果 ” ));
}
}

在启动 webservice_helloworld 工程的情况下，运行 WebServiceClientTest 类，可看到控制台包含如下信息：

hello, 阿蜜果

由此可看出调用 Web Service 成功。

四．总结

与 Axis相比，在实施Web Service时XFire更加简洁高效，并且XFire对Spring提供了强大的支持，可以非常方便地在Spring中使用XFire实施Web Service，因此XFire在短短的时间里成为了受Web Service开发者喜爱的框架。

XFire为客户端提供了多种访问Web Service的方式，如果可以获取客户端的窄接口类，则可以采用窄接口类调用Web Service。如果仅能获取WSDL，XFire也可以采用动态反射的机制调用Web Service。XFire为Eclipse提供了一个可以根据WSDL生成客户端存根代码的插件，相信XFire也将为其它非Java语言提供类似的插件。

技术可用性的一个很大的标准是它是否方便测试，XFire提供多种方式进行Web Service的测试，简单方便，给Web Service开发人员的测试工作带来了福音。

在本文中，笔者通过一个简单的helloWorld的Web Service例子，详细地说明了用XFire+Spring构建Web Service时配置文件的相关配置，以及测试的各种方法，也让读者见识了XFire与Spring的无缝集成，希望对读者学习XFire有点帮助。

webservice传递的数据只能是序列化的数据,典型的就是xml数据,这里我们也只讨论xml数据的传输.

有了一些对xml webservice的初步了解后,我们将切入正题,即是用一个具体的webservice事例的形式来讲解具体的webservice用法,用具体的事例来讲解一个概念我想怎么也要比单纯的说理能让人容易理解吧.

这里,我们将以一个简单的分布式课件搜索系统为例来讲解.使用VS2003为编译环境,C#为语言,SqlServcer2000为数据库.(这个例子来 源于一位网上朋友的文章的启发,觉得很能代表webservice的特点,就按那个想法做了这么个系统来示例了)

首先,明确我们要做什么.我们需要一个对客户的接口,也就是个站点,我们把它称做ServiceGatherSite,它是何种形式都无所谓, 甚至它本身 并不需要数据库,它只是提供给用户一个查询的接口,真正的服务,普通用户是不接触到的.然后,这里我们还需要若干个提供服务的站点,我们可以称它们为资源 站,这里为简单起见,假设有两个资源站,分别叫WebSiteA,WebSiteB,它们可以是不对外公布的,只是为了丰富查询数据而存在.最后,是我们 最需要关注的东西—资源站提供给ServiceGatherSite的服务.两个资源站,就有两个服务,我们称为SiteAService和 SiteBService.两个服务间没有任何关系,内部提供的方法也完全没关联,只是需要把方法如何使用告诉ServiceGatherSite,意思 是,服务只提供查询接口,返回的数据如何处理,服务本身并不管,全由使用服务的站点分配.

写了这么多,算是简要的介绍了下有关xml webservice的概念和我们这个例子的结构,下篇文章,我们将开始真正进入代码的设计阶段.

上篇文章介绍了些webservice的基本特性和我们例子的结构,这篇文章我们将开始具体的代码编写工作.

这个专题主要讲述的是webservice,因此这里我们的代码以Webservice相关为主,而其他工程,例如:ServiceGatherSite,WebSiteA等,只将简略介绍.

在VS2003中,开发一个webservice并不是件困难的事,首先,我们新建一个webservice项目(文件->新建->项目->C#->Web服务应用程序)

建完这个工程,我们将看到一个叫Service1.asmx的文件,这就是webservice的标准文件,它也有UI的概念,不过我们一般不 关注,因 此,我们查看其cs代码文件.如果你什么都还没做的话,将看见一个被注释掉的helloworld的WebMethod,把注释去掉,在运行,你就可以得 到最简单的webservice运行实例了.点击”helloworld”将执行其方法.显然,这个函数对我们的意义只在于宏观的了解了下web服务的写 法.

下面,我们将开始具体介绍webservice的写法.在代码文件里,如果我们写了一个函数后,希望此函数成为外部可调用的接口函数,我们必须 在函数上面 添上一行代码[WebMethod(Description="函数的描述信息")],如果你的函数没有这个申明,它将不能被用户引用.如:

以下是引用片段：

这个函数就是外部可调用的接口函数,对用户来说相当于一个API.如果某用户在引用了这个服务后,他调用HelloWorld()方法,他就将获得”HelloWorld”这个返回值.

看到这里,我们是不是发现,其实webservice并不是那么的神秘,它也不过只是个接口,对我们而言,侧重点依然是接口函数的编写.下面,我将给出我们的例子所需要的接口函数.

这是获取资源站点信息的一个接口函数.里面大部分的代码,我想对于有一定asp.net基础的朋友来说,都应该是一看就明白,这里只说明下CStoreProc,这是我封装的一个存储过程类,主要功能是执行各种类型的存储过程.

细心的朋友可能会发现这个函数的返回类型似乎比较特殊,是个xml的文档.我们在前面已经说过,webservice只能传输序列化数据,xml显 然满足 条件,但比如hash表之类的非序列化数据,是不能传输的,xml使用最为广泛,而且考虑到跨平台应用,所以这里我们只以xml数据的传输来示例.

接上篇文章,我们先简单解释下GetSiteAData(string AssignName)函数.

函数功能很简单,只是要返回查询结果,其数据格式是XmlDataDocument.当查询失败时(无匹配查询结果),我们构造一个xml,返 回一个空记 录.否则,我们把查询后的dataset生成一个XmlDataDocument,接下来,由于该项目的需要,我加入了一个循环,添加dataset里所 没有的节点,站点名称.在这之后,算是完成了一个符合我们期望格式的xml数据文档,我们把它返回.

好了,webservice的方法函数介绍完了(这里还有个web服务方法,稍后介绍),接下来我们的任务是怎么调用它了.首先把 webservice的 项目编译完成,假定我们这个服务是针对资源站点A的,我们不妨称其为ServiceA.先单独运行asmx文件,执行GetSiteAData (string AssignName)方法,将提示你输入参数,你输入要搜索的内容,点确认,将返回给你一个xml数据,并在ie上显示出来,这就是你搜索到的内容拉.

这里对ServiceA的工作再做点介绍,在我们这个项目里,它是资源站点A提供的服务,意思是,它查询的数据将全来源于站点A,而站点A资源添加在本项目也有专门的工程实现.

好了,回到正题.这里我介绍vs调用webservice的方法,其实其他平台的调用方法也是大同小异.首先我们介绍web引用方式,这种方式 我强烈建议 调试时使用,非常方便.右击引用,点添加web引用,输入你的webservice地址,如:http: //localhost/aspxproject/WebServiceSolution/SiteBService/service1.asmx,你必 须保证你输入的webservice存在.然后引用即可,注意:web引用名将作为你加入的webservice的名字空间.比如你输入了:SiteA, 那服务的实例化将是这样:SiteA.Service1 serviceA=new SiteA.Service1();(Service1是服务的类名).

完成了这一步,service的调用似乎变的那么简单,我们已经实现了远程实例化,接下来的远程调用也是一样的容易.下面给出资源采集站ServiceGatherSite的绑定代码(只采集A站点的信息)

以下是引用片段：

此段代码给出了xml转化成dataset的解决方案,虽然这不是必须的,但毕竟在asp.net里,dataset占的作用之重,谁都知道的.其 他的请 朋友们先看(呵呵,个中高手就免了),在下篇文章中将会有对它的一些解释与及多服务分布调用的解决方案,写了三篇了,发现似乎还是有些朋友看的,那我就献 丑继续写下去好了,大家有什么意见也希望提出,在下的理解存在偏驳也再所难免,希望谅解:)

接上篇文章,我们先简单说明下绑定函数.首先实例化ServiceA,这个和一般类的实例化并没有不同..接下来用xmlNode1来接受函数的返回值,接下来是构造xml,并将其转化为dataset,这是通用的方法,如果是刚接触不久的朋友,最好能记下这种方法.

接下来给出异步调用两个服务的代码

以下是引用片段：

这有两个需要注意的地方,一个是xml构造,还有就是异步调用的实现,请读者,自己理解

下面讲下通过dll来引用webservice的方法,我只把流程介绍下.

首先,在ie输入服务的地址,如:http://www.xxx.com/service.asmx

然后写输入http://www.xxx.com/service.asmx?wsdl

打开后,另存为xxx.wsdl

然后用vs的命令提示符来编译:wsdl /namespace:SiteA ServiceA.wsdl

生成名字空间为sitea的代理类

最后csc /out:ServiceA.dll /t:library Service1.cs ,其中service1.cs为代理类文件

最后引用dll就可以了.

对Web service 更精确的解释: Web services是建立可互操作的分布式应用程序的新平台。Web service平台是一套标准，它定义了应用程序如何在Web上实现互操作性。你可以用任何你喜欢的语言，在任何你喜欢的平台上写Web service ，只要我们可以通过Web service标准对这些服务进行查询和访问。

不管你的Web service是用什么工具，什么语言写出来的，只要你用SOAP协议通过HTTP来调用它，总体结构都一致。通常，你用你自己喜欢的语言(如VB 6或者VB.NET)来构建你的Web service，然后用SOAP Toolkit或者.NET的内建支持来把它暴露给Web客户。于是，任何语言，任何平台上的客户都可以阅读其WSDL文档，以调用这个Web service。客户根据WSDL描述文档，会生成一个SOAP请求消息。Web service都是放在Web服务器 (如IIS) 后面的，客户生成的SOAP请求会被嵌入在一个HTTP POST请求中，发送到Web服务器来。Web服务器再把这些请求转发给Web service请求处理器。请求处理器的作用在于，解析收到的SOAP请求，调用Web service，然后再生成相应的SOAP应答。Web服务器得到SOAP应答后，会再通过HTTP应答的方式把它送回到客户端。 bbs.bitsCN.com中国网管论坛

基本概念

SOAP

XML和XSD

WSDL(Web Services Description Language)

WSML(Web Services Meta Language)

什么时候使用Web Services

Web service是创建可互操作的分布式应用程序的新平台。Web service 的主要目标是跨平台的可互操作性。为了达到这一目标，Web service 是完全基于XML、XSD等独立于平台、独立于软件供应商的标准的。

Web service在应用程序跨平台和跨网络进行通信的时候是非常有用的。Web service适用于应用程序集成、B2B集成、代码和数据重用，以及通过Web进行客户端和服务器的通信的场合。

当然，Web service也不是万能的，你不能到处滥用Web service。在有些情况下，Web service 会降低应用程序的性能，而不会带来任何好处。例如，一台机器或一个局域网里面运行的同构应用程序就不应该用Web service 进行通信。

如何调用Web Services

客户端:取得服务端的服务描述文件WSDL，解析该文件的内容，了解服务端的服务信息，以及调用方式。根据需要，生成恰当的SOAP请求消息(指定调用的方法，已经调用的参数)，发往服务端。等待服务端返回的SOAP回应消息，解析得到返回值。
服务端:生成服务描述文件，以供客户端获取。接收客户端发来的SOAP请求消息，解析其中的方法调用和参数格式。根据WSDL和WSML的描述，调用相应的COM对象来完成指定功能，并把返回值放入SOAP回应消息返回给用户。

高层接口

使用高层接口，不需要知道SOAP和XML的任何信息，就可以生成和使用一个WebService。Soap Toolkit 2.0通过提供两个COM对象――SoapClient和SoapServer，来完成这些功能。

在客户端，只需要生成一个SoapClient实例，并用WSDL作为参数来调用其中的mssoapinit方法。SoapClient对象会自动解析 WSDL文件，并在内部生成所有Web Service的方法和参数信息。之后，你就可以像调用IDispatch接口里的方法一样，调用里面所有的方法。在VB或是脚本语言里，你甚至可以直接 在SoapClient对象名后面直接加上.方法(参数…)进行调用。

低层接口

要使用低层接口，你必须对SOAP和XML有所了解。你可以对SOAP的处理过程进行控制，特别是要做特殊处理的时候。

在客户端，首先要创建一个HttpConnector对象，负责HTTP连接。设定Connector的一些头部信息，比如EndPoinURL和 SoapAction等。如果网络连接需要使用代理服务器，那也要在这里设定相关的信息。接着创建SoapSerializer对象，用于生成Soap消 息。按照WSDL里定义，把所有参数按顺序序列化，得到一个完整的SOAP请求消息。该Soap消息，作为Payload通过HttpConnector 被发送到服务端。最后，生成一个SoapReader对象，负责读取服务端返回的SOAP消息，取得其中的返回值。

1. 158268 Query       SET autocommit=1
2. 158268 Query       SET autocommit=1
3. 158268 Query       SET autocommit=1
4. 158268 Query       SET autocommit=0
5. 158268 Query       commit
6. 158268 Query       SET autocommit=1
7. 158268 Query       SET autocommit=1
8. 158268 Query       SET autocommit=1
9. 158268 Query       SET autocommit=0
10. 158268 Query       commit

158268 Query       SET autocommit=1
158268 Query       SET autocommit=1
158268 Query       SET autocommit=1
158268 Query       SET autocommit=0
158268 Query       commit
158268 Query       SET autocommit=1
158268 Query       SET autocommit=1
158268 Query       SET autocommit=1
158268 Query       SET autocommit=0
158268 Query       commit

另外，你如果看mysqlreport，你会发现set_option和commt几乎占了mysql query的一半！！

原因是？

我们先看第一个问题：

1. 158268 Query       SET autocommit=0
2. 158268 Query       commit

158268 Query       SET autocommit=0
158268 Query       commit

这种日志产生的原因是hibernate查询时，如果所请求的对象在cache中，那么hibernate仍然会向数据库发出这样的两个sql语句。

再来看第二个问题

1. 158268 Query       SET autocommit=1

158268 Query       SET autocommit=1

这是因为当connection 被放回conn pool时，conn pool会恢复此连接取出时的autocommit状态。一般连接池里面的autocommit状态为true，所以每个查询都会紧跟着一个set autocommit＝1。

对第一个问题我们的解决方案：

那就是利用LazyConnectionDataSourceProxy

这个conn 代理的作用就是，只有当确实有必要时，他它向DB发出查询。一切没有必要的set autocommit=0 commit语句都不会发向数据库。

此class的详细作用请参见spring 文档

example配置如下:

1. <bean id=”dataSourceTarget” destroy-method=”close”>
2.   <property name=”driverClass”><value>com.mysql.jdbc.Driver</value></property>
3.   <property name=”jdbcUrl”><value>jdbc:mysql
4. ://localhost:3306/imagedb</value></property>
5.   <property name=”user”><value>admin</value></property>
6.   <property name=”password”><value></value></property>
7.
8.  <property name=”initialPoolSize” value=”60″ />
9.         <property name=”minPoolSize” value=”50″ />
10.         <property name=”maxPoolSize” value=”80″ />
11.         <property name=”maxIdleTime” value=”7200″ />
12.
13.         <property name=”idleConnectionTestPeriod” value=”360″ />
14.         <property name=”preferredTestQuery” value=”select 1″ />
15.         <property name=”acquireIncrement” value=”5″ />
16.         <property name=”acquireRetryAttempts” value=”50″ />
17.         <property name=”acquireRetryDelay” value=”1000″ />
18.         <property name=”breakAfterAcquireFailure” value=”true” />
19.
20.         <!–property name=”checkoutTimeout” value=”1000″ /–>
21.
22.         <property name=”autoCommitOnClose” value=”false” />
23.         <property name=”forceIgnoreUnresolvedTransactions” value=”false” />
24.         <property name=”unreturnedConnectionTimeout” value=”1000″ />
25.
26.         <property name=”maxStatements” value=”0″ />
27.         <property name=”maxStatementsPerConnection” value=”0″ />
28.
29.         <property name=”testConnectionOnCheckin” value=”true” />
30.         <property name=”testConnectionOnCheckout” value=”false” />
31.         <property name=”usesTraditionalReflectiveProxies” value=”false” />
32.
33.         <property name=”numHelperThreads” value=”5″ />
34. </bean>
35.
36. <bean id=”dataSource”>
37.   <property name=”targetDataSource”><ref local=”dataSource”/></property>
38. </bean>

<bean id=”dataSourceTarget” destroy-method=”close”>
<property name=”driverClass”><value>com.mysql.jdbc.Driver</value></property>
<property name=”jdbcUrl”><value>jdbc:mysql
://localhost:3306/imagedb</value></property>
<property name=”user”><value>admin</value></property>
<property name=”password”><value></value></property>

<property name=”initialPoolSize” value=”60″ />
<property name=”minPoolSize” value=”50″ />
<property name=”maxPoolSize” value=”80″ />
<property name=”maxIdleTime” value=”7200″ />

<property name=”idleConnectionTestPeriod” value=”360″ />
<property name=”preferredTestQuery” value=”select 1″ />
<property name=”acquireIncrement” value=”5″ />
<property name=”acquireRetryAttempts” value=”50″ />
<property name=”acquireRetryDelay” value=”1000″ />
<property name=”breakAfterAcquireFailure” value=”true” />

<!–property name=”checkoutTimeout” value=”1000″ /–>

<property name=”autoCommitOnClose” value=”false” />
<property name=”forceIgnoreUnresolvedTransactions” value=”false” />
<property name=”unreturnedConnectionTimeout” value=”1000″ />

<property name=”maxStatements” value=”0″ />
<property name=”maxStatementsPerConnection” value=”0″ />

<property name=”testConnectionOnCheckin” value=”true” />
<property name=”testConnectionOnCheckout” value=”false” />
<property name=”usesTraditionalReflectiveProxies” value=”false” />

<property name=”numHelperThreads” value=”5″ />
</bean>

<bean id=”dataSource”>
<property name=”targetDataSource”><ref local=”dataSource”/></property>
</bean>

第二个问题的解决方案：

通过conn pool 的jdbc url把autocommit设为false来解决，不过mysql driver好像不支持这个设置。

另外，如果你使用的是mysql，那么第一个问题还有一个更简单的解决方案，那就是在jdbcUrl中加入

useLocalSessionState=true

这可以达到和

1. LazyConnectionDataSourceProxy

LazyConnectionDataSourceProxy

一样的效果

Security.addProvider(new com.sun.crypto.provider.SunJCE());
 //获得密钥
 Key generateKey = new KeyTools().getKey(key.getBytes());
 Cipher encryptCipher = Cipher.getInstance("DES");

将用到该算法类对应的工程在Eclipse中发布为web工程，通过Eclipse启动Tomcat服务，可能会遇到这样的异常信息：
java.security.NoSuchAlgorithmException: Cannot find any provider supporting DES

网上的解决方案说什么sunjce_provider.jar路径问题啊，什么需要换成IBM的JDK之类的。。。。。
除了没换JDK，其他的方法都试过，但是没一个起作用的。到底有没有更好的解决方案？

其实很简单，将编译好的工程部署好，直接启动Tomcat而不是通过Eclipse的Tomcat插件启动，那么将不会出现这样的异常信息。

原因剖析：
对Eclipse的jar包，它隐掉了SUN公司关于某些Jar包的签名信息，这样当你在Eclipse中启动服务的话，就可能导致上述的异常。

个人觉得是这样的原因，因为目前为止也没看到有谁有更好的解决方案。

代码下载:


Struts2DataTags

七、<s:property>标签
Property顾名思义，可以与<s:bean>标签结合使用，一个是给bean赋值，一个是从bean中读取值。直接来看示例：
1．WebRoot\pages\dataTags\propertyTag.jsp
<%@ page contentType=”text/html; charset=GBK” %>
<%@ taglib prefix=”s” uri=”/struts-tags” %>
<html>
<head>
<title>Property Tag 示例</title>
</head>
<body>
<h2>Property Tag 示例</h2>
<!– Example to pick the value through bean class –>
<s:bean name=”com.sterning.companyName” id=”uid”>
<s:param name=”name”>sterning</s:param>
<s:property value=”%{name}” /><br>
</s:bean>
<!– Default value –>
<s:property value=”name” default=”Default Value” />
</body>
</html>

2．Bean
当然这里用到了Bean. com\sterning\ companyName.java，代码如下：
package com.sterning;
public class companyName {
private String name;
public void setName(String name){
this.name =name ;
}
public String getName(){
return name;
}
}

3．src”com”sterning” propertyTag.java
进行页面跳转

package com.sterning;
import com.opensymphony.xwork2.ActionSupport;
public class propertyTag extends ActionSupport {
public String execute() throws Exception{
return SUCCESS;
}
}

4．Struts.xml配置
<action name=”propertyTag”>
<result>/pages/dataTags/propertyTag.jsp</result>
</action>

代码下载:


Struts2DataTags

六、<s:set>标签

Set标签比较简单。Set标签用户将某一值赋给某一变量，因此，任何对该项值的引用都可以通过该变量来得到该值。该变量的活动范围可自定义。如下例中，定义一健/值对，对值的引用，直接引用值就可以。。请看示例
1．WebRoot\pages\dataTags\ setTag.jsp

<%@ page contentType=”text/html; charset=GBK” %>
<%@ taglib prefix=”s” uri=”/struts-tags” %>
<html>
<head>
<title>Set Tag 示例</title>
</head>
<body>
<h2>Set Tag 示例</h2>
<s:set name=”technologyName” value=”%{‘Java’}”/>
Technology Name: <s:property value=”#technologyName”/>
</body>
</html>
2．Struts.xml配置
<action name=”setTag”>
<result>/pages/dataTags/setTag.jsp</result>
</action>

3．运行效果

图6.<s:set>标签

代码下载:


Struts2DataTags

五、<s:param>标签

Param标签用于传递参数，如给<s:bean>标签传递参数。它有如下两个属性：
Name(String)：参数名；
Value(Object)：参数值。
1．WebRoot\pages\dataTags\paramTag.jsp

<%@ page contentType=”text/html; charset=GBK” %>
<%@ taglib prefix=”s” uri=”/struts-tags” %>
<html>
<head>
<title>Param Tag 示例</title>
</head>
<body>
<h2>Param Tag 示例</h2>
<ui:component>
<ui:param name=”empname”>Emp1</ui:param><br>
<ui:param name=”empname”>Emp2</ui:param><br>
<ui:param name=”empname”>Emp3</ui:param>
</ui:component>
</body>
</html>

2．Struts.xml配置
<action name=”paramTag”>
<result>/pages/dataTags/paramTag.jsp</result>
</action>

3．运行效果

图5.<s:param>标签

代码下载:


Struts2DataTags

四、<s:include>标签

<s:include>标签用于在当前页面中包含来自其它servlet或JSP页面的处理结果。由于是页面与页面（或servlet）之间的页面包含，因此不需要action来进行页面的跳转。
1．WebRoot\pages\dataTags\includeTag.jsp

<%@ page contentType=”text/html; charset=GBK” %>
<%@ taglib prefix=”s” uri=”/struts-tags” %>
<html>
<head>
<title>Include Tag 示例</title>
</head>
<body>
<h2>Include Tag 示例</h2>
<s:include value=”myBirthday.jsp” />
</body>
</html>

这里包含了另外一个页面myBirthday.jsp，其实相当于在JSP页面里包含其它的页面。原理一样的。

2．WebRoot\pages\dataTags\myBirthday.jsp

这个页面利用了上面所讲的<s:date>标签进行日期的格式化输出

<%@ page contentType=”text/html; charset=GBK” %>
<%@ taglib prefix=”s” uri=”/struts-tags” %>
<html>
<head>
<title>Include Tag 示例</title>
</head>
<body>
<table border=”1″ width=”35%”>
<tr>
<td><b>Date Format</b></td>
<td><b>Date</b></td>
</tr>
<tr>
<td>Day/Month/Year</td>
<td><s:date name=”myBirthday” format=”dd/MM/yyyy” /></td>
</tr>
<tr>
<td>Month/Day/Year</td>
<td><s:date name=”myBirthday” format=”MM/dd/yyyy” /></td>
</tr>
<tr>
<td>Month/Day/Year</td>
<td><s:date name=”myBirthday” format=”MM/dd/yy” /></td>
</tr>
<tr>
<td>Month/Day/Year Hour<B>:</B>Minute</td>
<td><s:date name=”myBirthday” format=”MM/dd/yy hh:mm” /></td>
</tr>
<tr>
<td>Month/Day/Year Hour<B>:</B>Minute<B>:</B>Second</td>
<td><s:date name=”myBirthday” format=”MM/dd/yy hh:mm:ss” /></td>
</tr>
<tr>
<td>Nice Date (Current Date & Time)</td>
<td><s:date name=”myBirthday” nice=”false” /></td>
</tr>
</table>
</body>
</html>

3．Struts.xml配置

<action name=”includeTag”>
<result>/pages/dataTags/includeTag.jsp</result>
</action>
4．运行效果

图4.<s:include>标签

代码下载:


Struts2DataTags

三、<s:date>标签

Data标签方便在页面进行格式化的日期输出。格式有多种可供选择。同时，还可以通过在properties属性文件中定义好”struts.date.format”参数的值，从而自定义格式输出。

Date标签包含三个属性，可以从下面的代码中感受一下，分别是：

Name:
Nice
Format

WebRoot\pages\dataTags\dateTag.jsp

<%@ page contentType=”text/html; charset=GBK” %>
<%@ taglib prefix=”s” uri=”/struts-tags” %>
<html>
<head>
<title>Date Tag 示例</title>
</head>
<body>
<h2>显示当前的时间</h2>
<table border=”1″ width=”35%”>
<tr>
<td><b>日期格式</b></td>
<td><b>日期</b></td>
</tr>
<tr>
<td>Day/Month/Year</td>
<td><s:date name=”currentDate” format=”dd/MM/yyyy” /></td>
</tr>
<tr>
<td>Month/Day/Year</td>
<td><s:date name=”currentDate” format=”MM/dd/yyyy” /></td>
</tr>
<tr>
<td>Month/Day/Year</td>
<td><s:date name=”currentDate” format=”MM/dd/yy” /></td>
</tr>
<tr>
<td>Month/Day/Year Hour<B>:</B>Minute</td>
<td><s:date name=”currentDate” format=”MM/dd/yy hh:mm” /></td>
</tr>
<tr>
<td>Month/Day/Year Hour<B>:</B>Minute<B>:</B>Second</td>
<td><s:date name=”currentDate” format=”MM/dd/yy hh:mm:ss” /></td>
</tr>
<tr>
<td>Nice Date (Current Date & Time)</td>
<td><s:date name=”currentDate” nice=”false” /></td>
</tr>
<tr>
<td>Nice Date</td>
<td><s:date name=”currentDate” nice=”true” /></td>
</tr>
</table>
</body>
</html>

2．src\com\sterning\beanTag.java
该项类更加简单，页面跳转

package com.sterning;
import com.opensymphony.xwork2.ActionSupport;
public class beanTag extends ActionSupport {
public String execute() throws Exception{
return SUCCESS;
}
}

3．Struts.xml配置
<action name=”dateTag”>
<result>/pages/dataTags/dateTag.jsp</result>
</action>
4．运行效果

图3.<s:date>标签

代码下载:


Struts2DataTags

二、<s:bean>标签

Bean标签，当然需要一个JavaBean。其的属性值的操作是经由Bean标签中的参数属性来进行赋值。当然，它还有一个id属性可以进行赋值，由于就可以在上下文中使用这个Bean。请看如下的页面：

1．WebRoot\pages\dataTags\beanTag.jsp，代码如下：
<%@ page contentType=”text/html; charset=GBK” %>
<%@ taglib prefix=”s” uri=”/struts-tags” %>
<html>
<head>
<title>Bean Tag 示例</title>
</head>
<body>
<h2>Bean Tag 示例</h2>
<s:bean name=”com.sterning.companyName” id=”uid”>
<s:param name=”name”>sterning</s:param>
<s:property value=”%{name}” /><br>
</s:bean>
</body>
</html>

可参其关联的JavaBean是com.sterning.companyName，同时参数name赋值为sterning。
2．首先创建Action进行跳转， src\com\sterning\beanTag.java，代码如下：

package com.sterning;
import com.opensymphony.xwork2.ActionSupport;
public class beanTag extends ActionSupport {
public String execute() throws Exception{
return SUCCESS;
}
}

然后创建JavaBean，src\com\sterning\companyName.java，代码如下：

package com.sterning;
public class companyName {
private String name;
public void setName(String name){
this.name =name ;
}
public String getName(){
return name;
}
}

3．Struts.xml的配置

这里配置很简单，与前面的例子差不多。
<action name=”beanTag”>
<result name=”success”>/pages/dataTags/beanTag.jsp</result>
</action>

4．运行效果

图2.<s:bean>标签

代码下载:


Struts2DataTags

一、<s:action>标签

Action标签，顾名思义，是用来调用Action的标签，在JSP中页面中，可以指向具体指定某一命名空间中的某一Action。而标签的主体用于显示及渲染Actionr的处理结果。

1．WebRoot\pages\dataTagssuccess.jsp处理页面
<%@ page contentType=”text/html; charset=GBK” %>
<%@ taglib prefix=”s” uri=”/struts-tags” %>
<html>
<head>
<title>Action Tag 示例</title>
</head>
<body>
<h2>Action Tag 示例</h2>
<s:action name=”success”>
<b><i>s:action标签用于在页面显示结果.</i></b></div>
</s:action>
</body>
</html>

这里使用<s:action>标签进行页面跳转，并用于显示处理的结果。

2．先来看struts.xml中的配置：
<action name=”actionTag” class=”com.sterning.actionTag”>
<result name=”success”>/pages/dataTags/success.jsp</result>
</action>
3．接着创建actionTag类：代码如下：
package com.sterning;
import com.opensymphony.xwork2.ActionSupport;
publicclass actionTag extends ActionSupport {
public String execute() throws Exception{
returnSUCCESS;
}
}

其实该类中没有做任何处理，只是进行页面跳转而已。

4．运行效果。

图1.<s:action>标签

2. Struts2 的各路标签
<s:if test=”exp”>…</s:if><s:elseif test=”exp”>…</s:elseif><s:else>…</s:else> 对应了 java 的 if/else if/else
<s:iterator…/> value 未指定是默认为 ValueStack 栈顶集合。id 为当前元素变量名。status 为 IteratorStatus 实例，包含奇还是偶行，当前索引，是否第一或最后一条记录。

3. iterator 可以迭代 List、Set 和数组，也可以迭代 Map，用法如下：

4. <s:append…/> 用于将多个集合拼成一个新集合，从而能用一个<s:iterator …/> 对多个集合迭代，也能拼 Map 的。<s:merge …/> 也是用来拼接集合，只是不像 <s:append …/> 那样依次保持着顺序，<s:merge …/> 是交错的。可以理解为前一个是深度拼接，后一个是广度拼接。

5. 在学习 <s:generator …/> 时我们能同时体验一下 Struts2 标签是如何操作栈的，当然这里指的是 ValueStack，而非 Java 的方法栈。
<s:generator val=”‘1,2,3′” separator=”,”> <!–字符串’123′以”,”分隔生成一个集合，并压栈–>
<s:iterator>      <!– 这里没有指定 value 属性，默认弹栈，并取一个元素压栈 –>
<s:property/> <!– 也没有指定 value 属性，默认也是取栈顶元素 –>
</s:iterator>     <!– 迭代完成则从集合遍历的最后一个元素出栈 –>
</s:generator>      <!– 最后，自动出栈，generator 生成的集合出栈 –>
汇编是基于寄存器操作的，而 Java 是基于栈的操作，Struts2 引入了存放在 request 中的 ValueStack 正好完美再现了 Java 的这一原始本性，并可使标签使用更简洁，灵活。Struts2 还有很多标签也有这个特性：
1) 生成的新实例，压栈，标签结束后自动出栈
2) 在未指定数据来源时，默认从栈顶取数据。
不禁回想起 Struts1 的 <nested:root> 等 nested 标签要显示的声明操作的根元素，是多么麻烦的一件事。
补充：如果指定了 <s:generator …/> 的 id 属性的话，同时还会把生成的集合放到 pageContext 中，key 就是 id 指定的值。

6. <s:subset …/> 是用来取集合子集的，可从 source (未指定则为栈顶集合) 集合的 start 位置起取 count 个元素。或者按自定义的 decider 条件，取符合条件的子集。你的 decider 要实现 SubsetIteratorFilter.Decider 接口的 decide(object element) 方法，符合条件的返回 true。此处不列出具体用法的实例。

7. <s:sort …/> 依据 comparator 指定的比较器，对 source (未指定则为栈顶集合) 集合排序。排序头的集合当然也是压入栈中，标签结束自动出栈。

8. <s:debug/> 会在页面生成一个 debug 链接，展开能看到 ValueStack 和 Stack Context 中的内容，该页面有显示用 #key 能获取到 Stack Context 中的值。<s:property …/> 在前面用很多次了，就相当于 Struts1 的 <bean:write …/>，value 未指定，输出栈顶值；若要输出的值为 null 时，指定了 default 属性则输出它；escape 指定是否忽略 HTML 代码，同 <bean:write …/> 的 ignore 属性。

9. <s:push …/> 用于将某个值压栈，标签结束后自动出栈，可方便某些操作，Struts1 的 <nested:root> 有类似功能。<s:set …/> 标签用于把某个值放入指定范围内，用 scope 指定，如 application、session、request、page、action。若未指定 scope 则放到 Stack Context 中；name 为新变量名；value 为欲处理的变量，未指定则取栈顶值。

10. 从前面的标签，你也许已经注意到，Struts2 常操作的几个数据结构有 ValueStack、pageContext 和 StackContext。例如：generator、sort、subset 等生成的新实例会压到栈顶，并在标签结束自动出栈；如果 sort、subset 未指定 source 源集合，则从栈顶取，iterator、property 也是一样的；若为 generator 指定了 id 属性，则生的集合会存到 pageContext 中，key 就是 id 对应值；如果为 bean 指定了 id 属性，则会把 bean 实例存入到 Stack Context 中，key 就是 id 对应值，Stack Conext 中的值可以用 #key 取得。其他标签类似的地方应该要注意到。