使用XFire+Spring構建Web Service

XFire是與Axis 2並列的新一代Web Service框架，通過提供簡單的API支持Web Service各項標准協議，幫助你方便快速地開發Web Service應用。

相 對於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的接口類.
 */
publicinterface HelloWorld {
    /**
     *對名字為name的人打招呼.
     *@paramname名字
     *@return返回打招呼的字符串
     */
    String sayHelloWorld(String name);
}
我們還需要建立一個對應的實現類，來實現sayHelloWorld的功能，該實現類即為HelloWorldImpl.java。該類的詳細內容如下：
package webservice;
/**
 *HelloWorld的實現類.
 */
publicclass 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:[e-mail]">AmigoXie</a>
 *@version1.0
 *Creationdate:2007-9-16-下午05:36:05
 */
publicclass WebServiceClientTest { 
    HelloWorld helloWorld = null;

    publicstaticvoid main(String[] args) throws Exception {
       WebServiceClientTest test = new WebServiceClientTest();
       test.testClient();
    } 
    
    publicvoid 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的測試類.
 */
publicclass WebServiceClientTest { 
    HelloWorld helloWorld = null;

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

    publicvoid 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有點幫助。

 

 

 

一．             本例概述

 

在本例中，我們將在業務邏輯類是一個用戶的業務邏輯類，包括創建用戶、獲取單個用戶、獲取用戶數組、獲取用戶列表四個方法，因該文講的是XFire+Spring構建webservice，所以在該例中我們並不涉及具體的數據庫操作，而只是提供模擬實現。方法描述如下：

 

1） 創建用戶方法：createUser(User user)

 

通過傳入User對象作為參數來才創建用戶；

 

2） 通過用戶名獲取用戶信息方法：getUser(String loginName)

 

根據用戶名獲取某用戶對象，該方法返回的是一個User對象；

 

3） 返回所有用戶的數組方法：getUserArray()

 

返回為User數組；

 

4） 返回所有用戶的列表的方法：getUserList()

 

返回為List對象，放入的對象為User類型。

 

二．             數據對象User.java

 

在上篇的例子中，src/webservice目錄下新建example2目錄，並在example2目錄下建立User.java文件，下面看看數據對象User.java的內容，代碼如下：

 

package webservice.example2;

import java.util.Date;

/**
 *用戶對象.  
 *@author<a href="mailto:[e-mail]">AmigoXie</a>
 *@version1.0
 *Creationdate:2007-9-28-上午10:42:44
 */
publicclass User implements java.io.Serializable {
    privatestaticfinallongserialVersionUID = 1L;

    /**用戶名*/
    private String loginName;

    /**用戶密碼*/
    private String password;

    /**手機號*/
    private String mobile;

    /**創建時間*/
    private Date createTime;

    public Date getCreateTime() {
       return createTime;
    }

    public void setCreateTime(Date createTime) {
       this.createTime = createTime;
    }

    public String getLoginName() {
       return loginName;
    }

    public void setLoginName(String loginName) {
       this.loginName = loginName;
    }

    public String getMobile() {
       return mobile;
    }

    public void setMobile(String mobile) {
       this.mobile = mobile;

    }

    public String getPassword() {
       return password;
    }

    public void setPassword(String password) {
       this.password = password;
    }

    public String toString() {
       StringBuffer sb = new StringBuffer();
       sb.append("loginName=" + this.loginName);
       sb.append("|password=" + this.password);
       sb.append("|mobile=" + this.mobile);
       sb.append("|createDate=" + this.createTime);
       return sb.toString();
    }
}

 

 

三．             用戶業務類UserService.java及其實現UserServiceImpl.java

 

下面讓我們來看看本例的業務邏輯接口類UserService.java的內容：

 

package webservice.example2;

import java.util.List;

/**
 *用戶業務類.
 *@author<a href="mailto:[e-mail]">AmigoXie</a>
 *@version1.0
 *Creationdate:2007-9-28-上午10:37:09
 */
publicinterface UserService {
    /**
     *獲取用戶對象.
     *@paramloginName用戶名
     *@return返回用戶對象
     */
    public User getUser(String loginName);

    /**
     *創建用戶.
     *@paramuser用戶對象
     *@return返回創建的對象的toString()方法返回的內容
     */
    public String createUser(User user);

    /**
     *獲取用戶信息數組.
     *@return返回用戶信息數組
     */
    public User[] getUserArray();
    
    /**
     *獲得用戶信息列表.
     *@return返回用戶信息列表
     *@author<a href="mailto:[e-mail]">AmigoXie</a>
     *Creationdate:2007-9-28-下午12:55:37
     */
    public List<User> getUserList();
}

 

它的實現類UserServiceImpl.java的內容如下：

 

package webservice.example2;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 *用戶業務實現類.
 *@author<a href="mailto:[e-mail]">AmigoXie</a>
 *@version1.0
 *Creationdate:2007-9-28-上午10:54:11
 */
publicclass UserServiceImpl implements UserService {
    /**
     *獲取用戶對象.
     *@paramloginName用戶名
     *@return返回用戶對象
     */
    public User getUser(String loginName) {
       User user = new User();
       user.setLoginName(loginName);
       user.setPassword("12345678");
       user.setMobile("13812345678");
       user.setCreateTime(new Date());
       return user;
    }

    /**
     *創建用戶.
     *@paramuser用戶對象
     *@return返回創建的對象的toString()方法返回的內容
     */
    public String createUser(User user) {
       user.setCreateTime(new Date());
       return user.toString();
    }

    /**
     *獲取用戶信息數組.
     *@return返回用戶信息數組
     */
    public User[] getUserArray() {
       User[] userList = new User[4];
       userList[0] = getUser("阿蜜果");
       userList[1] = getUser("sterning");
       userList[2] = getUser("娟子");
       userList[3] = getUser("老肖");
       return userList;
    }

    /**
     *獲得用戶信息列表.
     *@return返回用戶信息列表
     *@author<a href="mailto:[e-mail]">AmigoXie</a>
     *Creationdate:2007-9-28-下午12:55:37
     */
    public List<User> getUserList() {
       List<User> userList = new ArrayList<User>();
       userList.add(getUser("阿蜜果"));
       userList.add(getUser("sterning"));
       userList.add(getUser("娟子"));
       userList.add(getUser("老肖"));
       return userList;
    }
}

 

注意：getUserList()方法返回的List中需要采用泛型，不然會部署失敗。

 

到此為止，我們的業務已經完成，剩下的工作只是修改配置文件和編寫測試類來進行測試。讓我們繼續往下走吧。

 

四．             配置文件applicationContext.xml和xfire-servlet.xml的修改

 

在本小節中，我們需要修改配置文件。首先在applicationContext.xml文件中添加用戶邏輯bean的定義，添加的代碼如下：

 

<bean id="UserBean" class="webservice.example2.UserServiceImpl"/>

 

接下來我們還需要修改xfire-servlet.xml文件來暴露我們的Web Service，修改后的該文件內容如下所示：

 

<entry key="/UserService.ws">                    

 

<ref bean="UserService" />                

 

</entry>

 

並添加如下bean的定義：

 

bean  id="UserService" parent="baseWebService">
       <!-- 業務服務bean -->
       <property name="serviceBean" ref="UserBean" />
       <!-- 業務服務bean的窄接口類 -->
       <property name="serviceClass" value="webservice.example2.UserService" />
    </bean>

 

   我們的Web Service已經開發完成，啟動本項目后，可通過瀏覽器訪問：http://localhost:8080/webservice_helloworld/UserService.ws?wsdl，我們可以在瀏覽器中看到該例的WSDL信息。

 

五．             Web Service測試

 

在本小節我們將對上述完成的Web Service進行測試，首先我們在src目錄下的client.xml文件增加如下內容：

 

 獲取用戶信息的例子  -->
     <bean id="testUserWebService" class="org.codehaus.xfire.spring.remoting.XFireClientFactoryBean">
       <property name="serviceClass">              <value>webservice.example2.UserService</value> 
       </property>      
        <property name="wsdlDocumentUrl">         
<value>http://localhost:8080/webservice_helloworld/UserService.ws?wsdl</value>       
        </property>      
     </bean>

 

     接着我們在src/test目錄下建立UserServiceClientTest.java類，編寫測試代碼如下：

 

package test;

import java.util.List;

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

import webservice.example2.User;
import webservice.example2.UserService;

/**
 * 用戶業務測試類.    
 * @author <a href="mailto:[e-mail]">AmigoXie</a>
 * @version 1.0
 * Creation date: 2007-9-28 - 下午12:03:06
 */
public class UserServiceClientTest {
    public static void main(String[] args) throws Exception {
        UserServiceClientTest test = new UserServiceClientTest();
        test.testClient();
    } 
    
    public void testClient() throws Exception {
        ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "client.xml");    
        UserService userService = (UserService) ctx.getBean("testUserWebService");
        
        //測試getUser()方法
        System.out.println("--------------getUser()------------");
        User user = userService.getUser("阿蜜果");
        System.out.println(user);
        
        //測試getArray()方法
        System.out.println("--------------getUserArray()------------");
        User[] userArray = userService.getUserArray();
        for (int i = 0; i < userArray.length; i++) {
            System.out.println("i=" + i + "|" + userArray[i]);
        }
        
        //測試createUser()方法
        System.out.println("--------------createUser()------------");
        User newUser = new User();
        newUser.setLoginName("離離");
        newUser.setPassword("123");
        newUser.setMobile("13666666666");
        String result = userService.createUser(newUser);
        System.out.println(result);
        
        //測試getUserList()方法
        List<User> userList = userService.getUserList();
        System.out.println("--------------getUserList()------------");
        for (int i = 0; i < userList.size(); i++) {
            System.out.println("i=" + i + "|" + userList.get(i));
        }
    }
}