前言：本文不是專門講述Web Service技術的，讀者在閱讀本文之前需要具備一定的SOAP和Web Service知識基礎，同時對Weblogic Server的使用也應該熟悉。如果要自己動手實踐本文的例子，就需要安裝Weblogic Server 81,盡管本文是以weblogic server 81為測試環境，但是針對weblogic server 7下也是差不多的。本文只是起個拋磚引玉的作用，如果想深入研究Web Service的開發，還需要參考、學習相關的資料，包括Weblogic Service的相關文檔。
一、概述
在JBuilder中也支持開發基于weblogic的web service，不過實際上在JBuilder下開發web service也是基于ant任務來生成和構造web service的。但是，當初筆者在一個項目中使用JBuilder下自動生成構造ant腳本生成的web service時碰到了一個問題，通過JBuilder生成的web service，如果你的web service調用接口中存在一個或者多個String類型參數的時候，在生成的wsdl文件中對該接口的參數命名不會按照你的后端組件對應方法中參數的名字，而是以string、string0、string1…等形式命名的。而在那個項目中需要在Delphi環境中調用web service，問題就出現了，string在Delphi中是關鍵詞，產生了沖突，不能進行調用。于是筆者決定采用自編寫ant腳本的方式來生成和構造web service來解決前面所述Delphi調用的問題。
BEA Weblogic提供了一些Ant任務，用來幫助開發者生成、構造一個Web服務的重要部件，（例如：序列化類、客戶端jar支持庫、以及web-services.xml描述文件），并且把一個Weblogic Web 服務的所有部分打包成一個可部署的EAR文件。
BEA Weblogic所提供的Web服務Ant任務，支持從實現了Web Service接口的普通JAVA源文件和EJB jar生成Web Service部件，也支持從WSDL描述文件生成，同時支持基于http/https傳輸協議和JMS傳輸協議的Web Service。在這一節我們只講述通過基于一個普通JAVA類作為后端組件來實現的Web Service，傳輸協議使用http（基于https的方式將在后述關于Web Service安全的部分講述）。
二、使用Weblogic ant工具生成Web Service
我們先建立D:\wls_ws_demo的工作目錄，在此目錄下分別建立src、build、ddfiles、webapp、test目錄。具體用途后文會涉及到。
首先我們編寫一個實現了兩個Web Service接口的普通JAVA類：
package com.wnetw.ws.demo;
public class HelloWorldWS{
public String sayHello(){
return "Hello World!";
}
public String welcome(String name){
return "Hello " + name + ",Welcome to WebService!";
}
}
上面兩個方法就不需要解釋了，很簡單。把此類按封裝包一致的路徑放置在src目錄下。
下面是本示例中ant腳本文件內的屬性設置：
<property name="build.compiler" value="modern"/>
<property name="src.dir" value="src"/>
<property name="build.dir" value="build"/>
<property name="war.file" value="${build.dir}/
applications/HelloWorldWS.war" />
<property name="ear.file" value="${build.dir}/
applications/HelloWorldWS.ear" />
<property name="clients.lib" value="${build.dir}/
clientslib/HelloWorldWS_clients.jar"/>
<property name="bea.home" value="D:/bea"/>
<property name="wls.dir" value="${bea.home}/weblogic81/server"/>
<property name="wlslib.dir" value="${wls.dir}/lib"/>
<property name="wlsext.dir" value="${wls.dir}/ext"/>
<property name="namespace" value="http://www.wnetw.com/demo/"/>
<path id="classpath">
<dirset dir="${build.dir}/classes">
<include name="**"/>
</dirset>
<fileset dir="${wlslib.dir}">
<include name="**/weblogic.jar"/>
<include name="**/webservices.jar"/>
</fileset>
</path>
<property name="javac.fork" value="no"/>
<property name="javac.debug" value="no"/>
<property name="javac.optimize" value="on"/>
<property name="javac.listfiles" value="yes"/>
<property name="javac.failonerror" value="yes"/>
上面的屬性應該不是很難理解，關鍵的是對于bea weblogic server安裝目錄和構造生成文件的路徑說明，其次是對classpath的設置，需要用到的兩個weblogic庫是weblogic.jar和webservices.jar。
接著我們看看我們在本節中使用的Weblogic提供的Ant任務：
1、source2wsdd
source2wsdd Ant任務最基本的功能是根據我們編寫的普通JAVA類源文件生成一個Web Service所必需的兩個部件：web-services.xml和.wsdl描述文件。
下面是針對上面HelloWorldWS.java對應的Ant腳本：
<target name="genwsdd">
<source2wsdd javaSource="${src.dir}/com/wnetw/ws/
demo/HelloWorldWS.java"
ddFile="${build.dir}/wsddfiles/web-services.xml"
wsdlFile="${build.dir}/wsddfiles/HelloWorldWS.wsdl"
serviceURI="/HelloWorldWS">
<classpath refid="classpath"/>
</source2wsdd>
</target>
屬性說明
javaSource：指定web service的實現后端組件，這里是普通JAVA類com.wnetw.ws.demo HelloWorldWS.java。注意屬性里面是對源文件目錄路徑設置，而不是包路徑。
ddFile：生成的web service部署描述符文件web-services.xml的存放路徑。
wsdlFile：生成的.wsdl文件存放的路徑和名字。
serviceURI：客戶應用程序調用此Web服務的URL中的Web Service URI部分。注意：必須以“/”開頭。例如：/ HelloWorldWS 。同時這個URI屬性也會成為生成的web-services.xml 部署描述符文件中<web-service>元素的uri屬性。
例如：本機訪問本web service例子的url是http://localhost:7001/ WSDemo/ HelloWorldWS
上面的serviceURI屬性就指定了上述url中的/ HelloWorldWS這一部分。
2、clientgen
clientgen可以用來生成JAVA環境下客戶端應用調用一個Web Service客戶端jar支持庫。可以通過wsdl文件來生成，也可以通過一個包含web service實現的ear文件來生成。
下面是clientgen ant任務的腳本示例：
<target name="genclient">
<clientgen wsdl="${build.dir}/wsddfiles/HelloWorldWS.wsdl"
packageName="com.wnetw.ws.demo.client"
clientJar="${clients.lib}"
keepGenerated="false">
<classpath refid="classpath"/>
</clientgen>
</target>
這里采用從前面source2wsdd任務生成的wsdl文件來生成客戶端jar支持庫。通過wsdl屬性指定。
3、war
這是ant提供的標準任務，這里與其他普通的war包有一點區別是，需要把web-services.xml文件打包到war中去。
說明：需要準備web.xml，后面對于安全設置的時候還需要weblogic.xml文件，這里先都打包進去，這些文件都需要提前編輯準備好：
---Web.xml---
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web
Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<mime-mapping>
<extension>wsdl</extension>
<mime-type>text/xml</mime-type>
</mime-mapping>
</web-app>
---weblogic.xml---
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE weblogic-web-app PUBLIC "-//BEA Systems, Inc.//DTD Web
Application 7.0//EN" "http://www.bea.com/servers/wls700
/dtd/weblogic700-web-jar.dtd">
<weblogic-web-app>
</weblogic-web-app>
這個文件沒設置，在后面關于安全的處理里面需要這里配置角色映射。
下面是war ant腳本示例：
<target name="genwar">
<war destfile="${war.file}" webxml="webapp/WEB-INF/web.xml">
<classes dir="${build.dir}/classes"/>
<webinf dir="${build.dir}/wsddfiles">
<include name="web-services.xml"/>
</webinf>
<webinf dir="webapp/WEB-INF">
<include name="weblogic.xml"/>
</webinf>
</war>
</target>
4、ear
這也是ant標準任務，需要注意的是必須提前編寫application.xml文件，下面針對本文例子的application.xml文件：
<!DOCTYPE application PUBLIC '-//Sun Microsystems, Inc.//DTD J2EE
Application 1.3//EN' 'http://java.sun.com/dtd/application_1_3.dtd'>
<application>
<display-name></display-name>
<module>
<web>
<web-uri>HelloWorldWS.war</web-uri>
<context-root>WSDemo</context-root>
</web>
</module>
</application>
說明：context-root元素指定此Web Service所在Web應用的應用根。
例如：本機訪問本web service例子的url是http://localhost:7001/
WSDemo/ HelloWorldWS
上面的context-root元素就指定了上述url中的WSDemo這一部分。
下面是本文例子的ear ant任務腳本：
<target name="genear">
<ear destfile="${ear.file}" appxml="ddfiles/application.xml">
<fileset dir="${build.dir}/applications" includes="*.war"/>
</ear>
</target>
核心的ant任務說明完了，下面是完整的ant腳本文件：
--- build_wls_all.xml---
<project name="wls_ws_demo" default="all" basedir=".">
<property name="build.compiler" value="modern"/>
<property name="src.dir" value="src"/>
<property name="build.dir" value="build"/>
<property name="war.file" value="${build.dir}/applications/
HelloWorldWS.war" />
<property name="ear.file" value="${build.dir}/applications/
HelloWorldWS.ear" />
<property name="clients.lib" value="${build.dir}/clientslib/
HelloWorldWS_clients.jar"/>
<property name="bea.home" value="D:/bea"/>
<property name="wls.dir" value="${bea.home}/weblogic81/server"/>
<property name="wlslib.dir" value="${wls.dir}/lib"/>
<property name="wlsext.dir" value="${wls.dir}/ext"/>
<property name="namespace" value="http://www.wnetw.com/demo/"/>
<path id="classpath">
<dirset dir="${build.dir}/classes">
<include name="**"/>
</dirset>
<fileset dir="${wlslib.dir}">
<include name="**/weblogic.jar"/>
<include name="**/webservices.jar"/>
</fileset>
</path>
<property name="javac.fork" value="no"/>
<property name="javac.debug" value="no"/>
<property name="javac.optimize" value="on"/>
<property name="javac.listfiles" value="yes"/>
<property name="javac.failonerror" value="yes"/>
<target name="all" depends="clean,mdir,compile,genwsdd,
genclient,genwar,genear"/>
<target name="clean">
<delete dir="${build.dir}"/>
</target>
<target name="mdir">
<mkdir dir="${build.dir}"/>
<mkdir dir="${build.dir}/classes"/>
<mkdir dir="${build.dir}/applications"/>
<mkdir dir="${build.dir}/clientslib"/>
<mkdir dir="${build.dir}/wsddfiles"/>
</target>
<target name="compile">
<javac encoding="GBK" srcdir="${src.dir}" destdir=
"${build.dir}/classes">
<classpath refid="classpath"/>
</javac>
</target>
<target name="genwsdd">
<source2wsdd javaSource="${src.dir}/com/wnetw/ws/
demo/HelloWorldWS.java"
ddFile="${build.dir}/wsddfiles/web-services.xml"
wsdlFile="${build.dir}/wsddfiles/HelloWorldWS.wsdl"
serviceURI="/HelloWorldWS">
<classpath refid="classpath"/>
</source2wsdd>
</target>
<target name="genclient">
<clientgen wsdl="${build.dir}/wsddfiles/HelloWorldWS.wsdl"
packageName="com.wnetw.ws.demo.client"
clientJar="${clients.lib}"
keepGenerated="false">
<classpath refid="classpath"/>
</clientgen>
</target>
<target name="genwar">
<war destfile="${war.file}" webxml="webapp/WEB-INF/web.xml">
<classes dir="${build.dir}/classes"/>
<webinf dir="${build.dir}/wsddfiles">
<include name="web-services.xml"/>
</webinf>
<webinf dir="webapp/WEB-INF">
<include name="weblogic.xml"/>
</webinf>
</war>
</target>
<target name="genear">
<ear destfile="${ear.file}" appxml="ddfiles/application.xml">
<fileset dir="${build.dir}/applications" includes="*.war"/>
</ear>
</target>
</project>
運行ant生成Web Service：
打開命令行窗口，轉到工作目錄D:\wls_ws_demo下，在此目錄下先運行D:\bea\weblogic81\server\bin\setWLSEnv.cmd（此cmd文件具體路徑與你的weblogic platform81實際安裝目錄相關）進行環境設置，然后運行：D:\bea\weblogic81\server\bin\ant.bat -buildfile build_wls_all.xml。
運行結束，出現“BUILD SUCCESSFUL”，那就代表OK了。轉到工作目錄下的build目錄，你就會看到HelloWorldWS.ear這個文件。
三、測試Web Service
本節將講述對前一節里生成的Web Service HelloWorldWS進行測試。
啟動Weblogic Server，進入Weblogic Server控制臺，在Deployments->Applications下部署上節生成的HelloWorldWS.ear。
1、通過Weblogic自動生成的測試主頁測試
部署成功后，在瀏覽器中輸入http://localhost:7001/WSDemo/HelloWorldWS訪問Weblogic Server默認生成的上述HelloWorldWS Web Service的測試主頁。
如下圖：
圖上列出了HelloWorldWS Web Service上的兩個方法：welcome和sayHello。
點擊welcome連接進入wecome方法的測試頁，如下圖：
在上述頁面輸入“老Z”，提交后就會看到如下圖頁面：
測試的結果跟上節中的HelloWorldWS.java實現此方法的結果是一樣的。測試sayHello方法跟上面過程一樣。
在測試主頁中還能看到在JAVA環境下，基于clientgen ant任務生成的jar客戶端stub支持庫調用此HelloWorldWS Web服務的代碼示例。
2、使用JAVA程序調用Web Service
下面實際編寫一個java測試程序來調用上述Web Service。
--- HelloWorldWSTest.java ---
import com.wnetw.was.demo.client.*;
public class HelloWorldWSTest {
public static void main(String[] args){
try{
HelloWorldWS_Impl ws = new HelloWorldWS_Impl("http://localhost:7001
/WSDemo/HelloWorldWS?WSDL");
HelloWorldWSPort port = ws.getHelloWorldWSPort();
System.out.println(port.welcome(“老Z”));
}catch(Exception e){
e.printStackTrace();
System.out.println(e);
}
}
}
編譯、運行上述測試程序的時候首先需要weblogic客戶端webservice支持庫webserviceclient.jar，還需要前面clientgen ant任務生成的jar客戶端stub支持庫HelloWorldWS_clients.jar。在下面的編譯、運行測試程序的ant腳本中可以看到在classpath中引入了上述兩個jar。
編譯、運行測試程序的ant腳本如下：
<project name="wls_ws_demo" default="all" basedir=".">
<property name="build.compiler" value="modern"/>
<property name="bea.home" value="D:/bea"/>
<property name="wls.dir" value="${bea.home}/weblogic81/server"/>
<property name="wlslib.dir" value="${wls.dir}/lib"/>
<property name="wlsext.dir" value="${wls.dir}/ext"/>
<path id="classpath">
<fileset dir="${wlslib.dir}">
<include name="**/webserviceclient.jar"/>
</fileset>
<fileset dir="build/clientslib">
<include name="**/HelloWorldWS_clients.jar"/>
</fileset>
<pathelement path="test"/>
</path>
<property name="javac.fork" value="no"/>
<property name="javac.debug" value="no"/>
<property name="javac.optimize" value="on"/>
<property name="javac.listfiles" value="yes"/>
<property name="javac.failonerror" value="yes"/>
<target name="all" depends="compile,run"/>
<target name="compile">
<javac encoding="GBK" srcdir="test" destdir="test">
<classpath refid="classpath"/>
</javac>
</target>
<target name="run">
<java classname="HelloWorldWSTest">
<classpath refid="classpath"/>
</java>
</target>
</project>
運行上述ant腳本后，如果成功的話，應該得到類似下圖結果：
3、在VB下調用Web Service
下面我在VB環境下來調用下這個Web Service，筆者使用的是Visual Basic 6.0，要在VB下調用Web Service需要先安裝Microsoft SOAP toolkit。
新建一個VB工程，然后把Microsoft Soap Type Library引用進來，如下圖：
新建一個form1，添加一個按鈕command1，在form1源代碼窗口中整個拷貝如下代碼：
Dim soap As MSSOAPLib.SoapClient
Private Sub Command1_Click()
MsgBox soap.sayHello()
MsgBox soap.welcome("老Z")
If Err <> 0 Then
MsgBox "Web Service調用失敗： " + Err.Description
End If
End Sub
Private Sub Form_Load()
Set soap = New MSSOAPLib.SoapClient
On Error Resume Next
Call soap.mssoapinit("http://localhost:7001/WSDemo/HelloWorldWS?WSDL")
If Err <> 0 Then
MsgBox "初始化SOAP失敗： " + Err.Description
End If
End Sub
然后運行工程，點擊窗口上的按鈕就開始調用前面部署的Web Service（確保Weblogic Server在運行中），成功的話會得到如下圖的兩個MessageBox：
四、使用非內建數據類型
前面例子中的Web Service方法中使用的參數和返回值都是String，類似String，int等數據類型是屬于Weblogic web service所支持的內建類型，關于Weblogic web service所支持的內建數據類型請參見：http://e-docs.bea.com/wls/docs81/webserv/implement.html#1054236
所支持的XML非內建類型請參見：
http://e-docs.bea.com/wls/docs81/webserv/assemble.html#1060805
所支持的Java非內建數據類型請參見：
http://e-docs.bea.com/wls/docs81/webserv/assemble.html#1068595
WebLogic Server能夠對內建數據類型進行XML與Java表示之間的轉換。但是，如果你在web service操作中使用了非內建數據類型，那么你必須提供以下信息，以確保weblogic server能夠正確地進行轉換。
- 用于處理數據的Java表示與XML之間的轉換的序列化類；
- 包含了數據類型Java表示的Java類；
- 數據類型的XML Schema表示；
- web-services.xml部署描述文件中的數據類型映射信息。
Weblogic Server中帶有servicegen和autotype Atn任務，這兩個任務通過對web service的無狀態EJB或者Java類后端組件的內省，從而自動生成上述部件。上述Ant任務能夠處理許多非內建數據類型，所以大多數的開發者并不需要手工生成上述的部件。
有時，你可能也需要手工去創建非內建數據類型部件。因為你的數據類型可能很復雜，以致Ant任務不能正確生成前述部件。你也可能想要自己控制數據在XML和Java表示之間的轉換過程，而不依賴Weblogic Server所使用的缺省轉換程序。
本節將演示在Weblogic web service中如何處理非內建(自定義)的數據類型。
我們先編寫一個數值Bean類UserInfo，如下：
package com.wnetw.ws.demo;
import java.util.*;
public class UserInfo{
private Integer userid;
private String username;
private String sex;
private Date birthday;
private int level;
private double salary;
private telcodes list;
public UserInfo(){}
public Integer getUserid(){
return userid;
}
public void setUserid(Integer userid){
this.userid = userid;
}
public String getUsername(){
return username;
}
public void setUsername(String username){
this.username = username;
}
public String getSex(){
return sex;
}
public void setSex(String sex){
this.sex = sex;
}
public Date getBirthday(){
return birthday;
}
public void setBirthday(Date birthday){
this.birthday = birthday;
}
public int getLevel(){
return level;
}
public void setLevel(int level){
this.level = level;
}
public double getSalary(){
return salary;
}
public void setSalary(double salary){
this.salary = salary;
}
public List getTelcodes(){
return telcodes;
}
public void setTelcodes (List telcodes){
this. telcodes = telcodes;
}
}
在前文中的后端組件類HelloWorldWS.java中增加一個方法：
public UserInfo getUserInfo(Integer userid){
UserInfo userinfo = new UserInfo();
userinfo.setUserid(userid);
userinfo.setUsername("李澤林");
userinfo.setSex("男");
userinfo.setBirthday(new Date());
userinfo.setLevel(2);
userinfo.setSalary(1000.51);
List telcodes = new ArrayList();
telcodes.add("123");
telcodes.add("321");
userinfo.setTelcodes (telcodes);
return userinfo;
}
在這個方法里，返回值是UserInfo，這是我們前面定義的數值Bean，由于這是非內建類型，而且也不屬于受支持的非內建類型，所以需要我們必須自己來處理XML和UserInfo Java表示數據類型之間的轉換。
在本文的例子中，我們使用Weblogic Server的autotype任務來做這件事情。我們先在build目錄建一個autotype目錄，然后在前文中ant完整腳本中的compile任務之后增加下述腳本：
<target name="gentypeinfo">
<autotype javatypes="com.wnetw.ws.demo.UserInfo"
targetNamespace="${namespace}"
packageName="com.wnetw.ws.demo"
destDir="${build.dir}/autotype"
keepGenerated="true">
<classpath refid="classpath"/>
</autotype>
<copy todir="${build.dir}/classes">
<fileset dir="${build.dir}/autotype">
<include name="**/*.class"/>
</fileset>
</copy>
</target> autotype Ant任務有幾個常用屬性，下面簡要說明下：
javatypes：需要進行類型轉換的非內建（自定義）數據類型java類，注意取值是全限定類名，不需要帶上java或者class擴展名。如果存在多個這樣的數據類型類，用逗號“,”隔開；
targetNamespace：在對數據類型映射到XML的時候使用的命名空間；
packageName：生成的序列化相關類的封裝包；
destDir：生成的序列化相關類存放的目錄；
keepGenerated：是否保留中間java源文件，取值為：true或者false。
關于autotype任務的詳細信息請參考：
http://e-docs.bea.com/wls/docs81/webserv/anttasks.html#1080062
上述ant任務成功運行后就會生成build/autotype/目錄下生成types.xml文件以及按包封裝的數據轉換類的源文件和class文件。
由于增加了自定義數據類型，所以我們還得更新source2wsdd任務腳本，以下是增加了自定義數據類型處理后的source2wsdd任務腳本：
<target name="genwsdd">
<source2wsdd javaSource="${src.dir}/com/wnetw/ws/demo/HelloWorldWS.java"
typesInfo="${build.dir}/autotype/types.xml"
ddFile="${build.dir}/wsddfiles/web-services.xml"
wsdlFile="${build.dir}/wsddfiles/HelloWorldWS.wsdl"
serviceURI="/HelloWorldWS">
<classpath refid="classpath"/>
</source2wsdd>
</target>
跟以前的腳本相比，增加了typesInfo屬性來指定自定義數據類型的XML描述文件。
增加了對自定義數據類型支持后的完整腳本請參考本文代碼下載文件。
按照第一節所述方法運行ant腳本build_wls_all.xml后，再部署build\applications\目錄下的HelloWorldWS.ear。就可以按照以前說的方法進行測試了。
這一次在Weblogic Server自動生成的web service測試主頁：
http://localhost:7001/WSDemo/HelloWorldWS
可以發現多了一個叫getUserInfo的方法連接，進入此方法的調用測試頁面，調用此方法后就可以看到此web service方法的調用結果，以下是結果截圖：
從調用測試結果頁面可以看到，這一次的Return Value是：
com.wnetw.ws.demo.UserInfo@82d235
這正是我們的web service方法返回值類型類型的一個對象，圖中的下面也以SOAP消息的形式描述了調用的輸入和返回結果。
我們接著修改測試類HelloWorldWSTest.java，如以下：
import com.wnetw.ws.demo.client.*;
import com.wnetw.ws.demo.UserInfo;
public class HelloWorldWSTest {
public static void main(String[] args){
try{
HelloWorldWS_Impl ws = new HelloWorldWS_Impl("http://localhost:7001
/WSDemo/HelloWorldWS?WSDL");
HelloWorldWSPort port = ws.getHelloWorldWSPort();
System.out.println(port.sayHello());
System.out.println(port.welcome("老Z"));
System.out.println("開始測試自定義數據類型的返回值。。。");
UserInfo info = port.getUserInfo(100);
System.out.println(info);
System.out.println(info.getUsername());
}catch(Exception e){
e.printStackTrace();
System.out.println(e);
}
}
}
看看以下代碼好像有點問題，UserInfo info = port.getUserInfo(123);我們在HelloWorldWS.java類中定義的對應方法是getUserInfo(Integer userid)，參數是Integer的，但是上述測試類代碼中卻使用int類型，這是正確的。我們可以把clientgen任務中的keepGenerated屬性設為true，把自動生成的java源代碼保留下來，build成功后，我們打開build\clientslib目錄下HelloWorldWS_clients.jar文件中的com.wnetw.ws.demo.client.HelloWorldWSPor.java源文件，可以看到如下代碼：
package com.wnetw.ws.demo.client;
/**
* Generated interface, do not edit.
*
* This stub interface was generated by weblogic
* webservice stub gen on Sat Sep 17 16:11:21 CST 2005 */
public interface HelloWorldWSPort extends java.rmi.Remote{
/**
* welcome
*/
public java.lang.String welcome(java.lang.String name)
throws java.rmi.RemoteException ;
/**
* sayHello
*/
public java.lang.String sayHello()
throws java.rmi.RemoteException ;
/**
* getUserInfo
*/
public com.wnetw.ws.demo.UserInfo getUserInfo(int userid)
throws java.rmi.RemoteException ;
} 其中的getUserInfo(int userid)方法是使用int參數的！如果你使用Integer類型參數，反而會編譯通不過！只能認為這是weblogic server ant任務對數據類型映射的具體實現了，如果你仔細看了本節前面所述對java內建數據類型的支持列表，那么也是好理解的，因為java數據類型到XML Schema數據類型映射中，java中的int和java.lang.Integer都映射到了int。所以web service服務端接收到的SOAP消息中只會是XML Schema int類型，無法區分客戶端使用的會是int或者java.lang.Integer，所以在ant工具根據wsdl文件自動生成客戶端支持類的時候就只能使用int了，沒法區分int或者java.lang.Integer。這是個有意思的問題^-^一不小心也許會在你工作中浪費不必要的時間。當然如果有必要，你完全可以手動修改、甚至完全自己來生成客戶端支持庫和數據類型轉換類。不過嘛，除了出于研究和特殊情況外這是沒有必要的。
我們接著看看HelloWorldWS_clients.jar中還有什么東西，發現有個language_builtins這樣的包，從包名也許你能猜到這是干什么的，是對java語言內建數據類型處理的包，此包下面是util包，里面有ListCodec.class類?？纯次覀兊腢serInfo類，里面使用了List類，這個包里面的類正是用來處理java.util.List數據類型的，java.util.List屬于Weblogic server web service所支持的非內建數據類型，也就是說不需要通過autotype明確來標志生成相關的數據轉換類和類型信息。但是，java.util.List又有別于int、java.lang.String等wls web service所支持的內建類型，對于java.util.List等受支持的非內建類型由ant任務自動生動相關數據類型處理信息，不需要手工干預。對比來看，int、java.lang.String等wls web service所支持的內建類型是直接映射，不需要數據類型轉換相關類。Java.util.List最終映射成了XML Shema SOAP Array類型。其他類型請參考：http://e-docs.bea.com/wls/docs81/webserv/assemble.html#1068595
運行修改后的build_wls_test.xml腳本，成功的話應該得到如下圖類似結果：
增加了自定義數據類型后，VB測試客戶端的處理也得增加一些處理來測試返回值為UserInfo的web service方法，如下面代碼：
Set Nodes = soap.getUserInfo(100)
MsgBox Nodes(0).nodeName + ":" + Nodes(0).Text
MsgBox Nodes(1).nodeName + ":" + Nodes(1).Text
MsgBox Nodes(2).nodeName + ":" + Nodes(2).xml
MsgBox Nodes(3).nodeName + ":" + Nodes(3).Text
MsgBox Nodes(4).nodeName + ":" + Nodes(4).Text
MsgBox Nodes(5).nodeName + ":" + Nodes(5).Text
MsgBox Nodes(6).nodeName
完整VB測試客戶端代碼請見本文附帶下載代碼。
五、配置Web Service安全
Weblogic Web Service包括三種不同概念的安全設置：
- 消息層安全：對SOAP消息中數據的數字簽名或者加密；
- 傳輸層安全：使用SSL來保證客戶應用與Web Service之間連接的安全性；
- 訪問控制：指定何種用戶、組、角色被允許訪問該Web Service。
在這里我們主要針對訪問控制概念上的安全處理。
Weblogic Web Service最終是作為一個標準的J2EE ear打包文件提供進行部署的，其中包含了一個war包，也就是說web service是以web應用的形式提供并部署的，這從前面的章節就可以看出。
所以，針對web service的訪問控制安全處理與J2EE中對于Web資源的訪問控制處理是一樣的。具體的說就是對特定Web資源增加安全約束。具體配置就是通過在Web應用部署描述符web.xml增加相應的元素：需要進行安全約束的資源集合、授權訪問的角色列表、對用戶數據的安全約束、角色映射等信息。
在這里，我們需要對前面用到的web.xml文件進行修改，如下所示：
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web
Application 2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
<mime-mapping>
<extension>wsdl</extension>
<mime-type>text/xml</mime-type>
</mime-mapping>
<security-constraint>
<display-name>SecurityConstraint</display-name>
<web-resource-collection>
<web-resource-name>HelloWorldWS</web-resource-name>
<url-pattern>/*</url-pattern>
<http-method>GET</http-method>
<http-method>POST</http-method>
</web-resource-collection>
<auth-constraint>
<role-name>testrole</role-name>
</auth-constraint>
</security-constraint>
<security-role>
<role-name>testrole</role-name>
</security-role>
</web-app>
然后運行ant構造腳本，部署ear。部署成功后，你會在weblogic server運行命令行窗口中看到如下類似信息：
<2005-9-24 下午22時03分45秒 CST> <Warning> <HTTP> <BEA-101304>
<Webapp: ServletC
ontext(id=11680063,name=WSDemo,context-path=/WSDemo),
the role: testrole defined
in web.xml has not been mapped to principals in
security-role-assignment in web
logic.xml. Will use the rolename itself as the principal-name.>
這是因為沒有進行角色映射，所以直接使用角色名作為用戶名了。這只是一個警告信息，沒有關系。后面將會講述怎么進行角色映射。
然后進入weblogic server Console，新建一個名叫testrole的用戶。接著在左側目錄樹中一次展開Deployments-Applications- HelloWorldWS- WSDemo，在WSDemo節點上鼠標右擊，選擇Define Security Policy…
在Policy Condition項選擇User name of the caller，點擊增加，在接著出現的窗口中填入testrole,OK之后，點擊上圖頁面中的Apply。接下來就可以跟以前一樣測試了。
瀏覽器中輸入http://localhost:7001/WSDemo/HelloWorldWS，這個時候會彈出來一個登陸框，如下圖：
現在可以看到，訪問控制起作用了。輸入testrole以及擬增加用戶的時候指定的密碼后，就能進入到和以前一樣的測試主頁了。
上面那種使用角色名和用戶名對應的方式顯示在實際應用中是不方便的，因為具體會有什么樣的用戶會訪問此web service在構建時是不確定的。我們可以使用角色映射的方式來避免這個問題。
進行角色映射需要在weblogic.xml文件中配置，下面我將對testrole映射到一個group，weblogic.xml文件如下所示：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE weblogic-web-app PUBLIC "-//BEA Systems, Inc.//DTD Web
Application 7.0//EN" "http://www.bea.com/servers/wls700/dtd
/weblogic700-web-jar.dtd">
<weblogic-web-app>
<security-role-assignment>
<role-name>testrole</role-name>
<principal-name>test_group</principal-name>
</security-role-assignment>
</weblogic-web-app>
在web.xml文件中指定的授權訪問角色testrole映射到了test_group，也就是說test_group組中的所有用戶都有權訪問。這樣一來用戶授權和實現就解耦了。
使用ant腳本重新構建，然后部署ear。接著進入weblogic server console，刪除testrole用戶，新建test_group組，新建一個叫test_user的用戶，并指派給test_group組。接著按照前面一樣Define Security Policy，這一次在Policy Condition部分選擇Caller is member of the group，然后點Add進入授權group指定頁面，輸入test_group，點增加-點OK，回到Define Security Policy主頁面，點擊Apply就好了。
然后我們在瀏覽中進入http://localhost:7001/WSDemo/HelloWorldWS，彈出登陸框，這一次我們可以使用test_group中的任何成員用戶來登陸了，前面例子是test_user。這樣在以后，需要分配新的用戶授權訪問此Web Service的時候就知需要在Cosole在test_group中增加一個成員就行了，不需要重新構建web service了。
加入了訪問控制后，在調用web service的時候就需要提供授權憑證了，下面是需要增加的代碼信息：
- JAVA客戶
HelloWorldWS_Impl ws = new HelloWorldWS_Impl("http://localhost:7001/WSDemo/HelloWorldWS?WSDL");
HelloWorldWSPort port = ws.getHelloWorldWSPort("test_user","test_user");
改成
HelloWorldWS_Impl ws = new HelloWorldWS_Impl();
//因為加入了訪問控制，所以對于http://localhost:7001/WSDemo/HelloWorldWS?WSDL的訪問也需授權，所以我們使用缺省構建器，這樣就會使用客戶端支持庫jar中的靜態wsdl文件了。
HelloWorldWSPort port = ws.getHelloWorldWSPort(“test_user”, “test_user”);
//后面的參數是test_user的密碼，根據你具體的密碼更改
- VB客戶端
Call soap.mssoapinit("HelloWorldWS.wsdl")
‘由于http://localhost:7001/WSDemo/HelloWorldWS?WSDL需要授權訪問，所以我們把腳本生成的HelloWorldWS.wsdl文件直接拷貝到VB項目目錄下，使用這個靜態文件來初始化soap對象。
‘后面增加下屬代碼
soap.ConnectorProperty("AuthUser") = "test_user"
soap.ConnectorProperty("AuthPassword") = "test_user"
在我們運行上述兩個測試程序的時候會發現調用不成功。原因接下來進行說明。
我們打開工作目錄中下build\wsddfiles這個目錄中的HelloWorldWS.wsdl這個文件，在最后可以看到下面的service元素內容，如下：
<service name="HelloWorldWS">
<port name="HelloWorldWSPort"
binding="tns:HelloWorldWSPort">
<soap:address location="http://pls.set.the.end.point.address/">
</soap:address>
</port>
</service>
問題就出在這里，soap:address節點的location屬性有問題，因為客戶端soap初始化后，會使用這個URL來調用本wsdl中描述的web service操作，顯然這個地址與我們部署的實際地址是不一樣的。所以我們把location屬性改為我們部署的web service實際訪問URL：
http://localhost:7001/WSDemo/HelloWorldWS。這就是上述兩個測試程序不能正確運行的原因。
筆者也沒有找到如何在生成web service部件時設置此正確屬性的方法，正是因為需要修改上述wsdl文件屬性，所以我們需要把build腳本分成兩部分來執行，先生成相關部件，然后修改wsdl文件的上述屬性，最后才進行打包和客戶端支持庫的生成，把build_wls_all.xml分開成了build_wls_1.xml和build_wls_2.xml兩個build腳本文件。在運行完后build_wls_1.xml修改上述屬性，然后運行build_wls_2.xml即可。
部署成功后，就可以測試上面兩個調用例子了，注意把修改好的wsdl文件拷貝到VB項目目錄中去。
如果在web.xml中<security-constraint>元素里加入下述項目
<user-data-constraint>
<transport-guarantee>CONFIDENTIAL</transport-guarantee>
</user-data-constraint> 那就會強制要求客戶端使用https進行訪問，其他更多信息請參考J2EE中Web應用安全方面的資料。
六、雜項設置
本節要說的實際也是安全性方面的問題，只不過和一般的安全性概念不一樣，這里講的是針對在生產部署環境下的考慮。
1、定制主頁
在生產環境下，一般是不允許公開web service默認主頁的。其次由于通過主頁：
http://localhost:7001/WSDemo/HelloWorldWS?WSDL
訪問的wsdl描述符文件是動態生成，同時加入了訪問控制安全約束后，客戶程序訪問此文件也存在問題，所以通常在生產環境下將禁止訪問web service默認主頁以及動態wsdl文件，可以使用專門的靜態web站點來提供必要的信息，以及通過靜態web站點來發布wsdl。
要禁用默認主頁以及wsdl文件，需要在web-services.xml描述符文件中進行設置。如下所示在web-service節點中加入下面兩個屬性：
exposeWSDL="False"
exposeHomePage="False"
修改后類似下面示例：
。。。
<web-services>
<web-service name="HelloWorldWS"
targetNamespace="http://tempuri.org/"
uri="/HelloWorldWS"
exposeWSDL="False"
exposeHomePage="False">
。。。
這個修改也需要在運行build_wls_1.xml之后進行修改，才能保證應用打包部署后使得此設置生效。
在禁止了默認主頁和WSDL文件后，為了保證web service更新后不需要更新客戶程序的文件，所以最好建立一個靜態web站點來發布web service，也就是發布wsdl文件。在用于發布wsdl的web應用中需要在web.xml中加入以下的Mime類型映射：
<mime-mapping>
<extension>wsdl</extension>
<mime-type>text/xml</mime-type>
</mime-mapping>
2、啟用https協議
除了上一節中在web.xml中加入
<user-data-constraint>
<transport-guarantee>CONFIDENTIAL</transport-guarantee>
</user-data-constraint>
來啟用https通訊協議外，還可以在通過在web-service.xml文件中，在web-service（注意不是web-services）節點中加入下面屬性：
protocol="https"
上述屬性能保證客戶端必須使用https來訪問本web service。
七、結束語
本文只是針對很小的一方面來講述基于weblogic ant任務開發web service的，只是起個拋磚引玉的作用。其次，通過本文你也能了解到web service的本質過程，無論通過什么工具來開發，本質上都是生成基礎部件，然后打包。如果需要全面了解weblogic server web service開發方面的知識請參考bea文檔：
http://e-docs.bea.com/wls/docs81/webservices.html
同時本文使用的環境是window 2000 server和weblogic platform8.1英文版。
本文示例項目代碼可從以下地址下載：
http://www.wnetw.com/jclub_resources/technology/attachfiles/wls_ws_demo.rar
時間：2005-12-23
作者：
Russell Miles瀏覽次數：
3616
本文關鍵字：
Spring,?
Java,?
AOP,?
crosscutting,?
面向方面編程,?
橫切,?
Cuckoo's Egg模式 在本系列的第一部分，我介紹了如何實現面向方面領域的“HelloWorld”：跟蹤和記錄方面。利用Spring框架所提供的面向方面編程(Aspect-Oriented Programming，AOP)功能，您看到了如何使用before-、after-和基于異常的通知，以及如何使用基于正則表達式的簡單切入點。跟蹤和記錄方面提供了非常不錯的上手例子，而本文將進一步介紹一種新的通知形式：around通知。
比起第一部分中介紹的那些通知類型，around形式的通知是一種更具侵入性也更強大的面向對象概念。本文將描述around通知的每個特性，以便您可以在自己的Spring AOP應用程序中正確地使用它。在本文最后，我將向您展示如何使用around通知來截獲和改變應用程序中各個特性相互作用的方式，以便實現Cuckoo's Egg（杜鵑的蛋）面向方面設計模式。
概述Spring AOP、IoC和代理
在第一部分，我們快速瀏覽了Spring的一些AOP特性，而沒有闡明Spring如何實現AOP的細節。要理解Spring框架如何運轉，尤其是它如何實現其AOP功能，首先您要明白，Spring是一個依賴于控制反轉(Inversion of Control，IoC)設計模式的輕量級框架。
注意：本文的目的不是要深入介紹IoC模式，介紹IoC只是為了使您明白該設計模式是如何影響Spring AOP實現的。有關IoC模式的更詳細的介紹請參見本文末尾的參考資料。
IoC設計模式的出現已經有一段時間了。一個最明顯的例子就是J2EE架構本身。隨著企業開發尤其是J2EE平臺的出現，應用程序開始依賴于由外部容器所提供的一些特性，比如bean創建、持久性、消息傳遞、會話以及事務管理。
IoC引入了一個新概念：由組件構成的框架，它與J2EE容器有許多類似之處。IoC框架分離了組件所依賴的功能，并且，根據Sam Newman文章中的說法，提供了“連接組件的‘膠水’”。
對組件所依賴特性的控制 被反轉 了，這樣外部框架就可以盡可能透明地提供這些特性了。IoC模式真正意識到了從傳統的由依賴于功能的組件來負責這些功能，到由獨立的框架來配置和提供這些功能的方式轉變。
圖1顯示了一些構成IoC模式的不同組件角色的例子。
圖1. 沒有對BusinessLogic bean應用方面時的順序圖.
圖字：
Component：組件
Provides Facilities：提供功能
Relies on and conforms to：依賴于并服從
Manages the services the framework can then use to provide facilities：管理框架隨后可以用來提供功能的服務
Service：服務
Your Component：您的組件
IoC Framework：IoC框架
External services：外部服務
IoC模式使用3種不同的方法來解除組件與服務控制的耦合：類型1、類型2和類型3。
- 類型1：接口注入
這是大部分J2EE實現所使用的方法。組件顯式地服從于一組接口，帶有關聯的配置元數據，以便允許框架對它們進行正確的管理。
- 類型2：Setter注入
外部元數據被用來配置組件相互作用的方式。在第一部分中，我們就是使用這種IoC方法利用springconfig.xml文件來配置Spring組件的。
- 類型3：構造函數注入
組件（包括構造組件時要用的參數）注冊到框架，而框架提供組件的實例以及所有要應用的指定功能。
IoC在組件開發和企業開發中越來越受歡迎。IoC的實際例子包括傳統的J2EE解決方案，比如：JBoss、Apache基金會的Avalon項目以及本文的Spring框架。實際上，Spring框架構建于IoC模式的基礎上是為了幫助將它的輕量級功能注入到它的相關應用程序的組件中。
那么IoC對于Spring AOP有何意義呢？Spring的IoC特性是使用IoC springconfig.xml配置文件對應用程序應用方面的推動因素之一。springconfig.xml配置文件通知Spring框架運行時有關應用程序的組件要被注入的功能類型的信息，所以自然輕量級的AOP功能就以同樣的方式應用了。然后Spring使用代理模式圍繞現有的類和bean實現指定的AOP功能。
圖2顯示了Spring及其IoC框架如何使用代理對象提供AOP功能（根據springconfig.xml文件中的IoC配置。）
圖2. springconfig.xml配置文件改變了Spring框架IoC，以便隨后向第一部分中的一個順序圖提供AOP代理（單擊圖像查看大圖）
在本系列下面的部分，您將不斷看到現在包含在順序圖中的代理對象。這只是為了說明對于Spring AOP來說沒有“魔法”，實際上只有一個面向對象設計模式的良好例子。
回到AOP：使用around通知的積極方面
在第一部分，您看到了如何使用Spring AOP來實現跟蹤和記錄方面。跟蹤和記錄都是“消極”方面，因為它們的出現并不會對應用程序的其他行為產生影響。它們都使用了消極的before和after形式的通知。
但是如果您希望改變應用程序的常規行為呢？例如說，您希望重寫一個方法？這樣的話，您就需要使用更積極的around形式的通知。
第一部分的簡單例子應用程序包括IbusinessLogic接口、BusinessLogic類和MainApplication類，如下所示：
public interface IBusinessLogic
{
public void foo();
}
public class BusinessLogic
implements IBusinessLogic
{
public void foo()
{
System.out.println(
"Inside BusinessLogic.foo()");
}
}
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class MainApplication
{
public static void main(String [] args)
{
// Read the configuration file
ApplicationContext ctx =
new FileSystemXmlApplicationContext(
"springconfig.xml");
//Instantiate an object
IBusinessLogic testObject =
(IBusinessLogic) ctx.getBean(
"businesslogicbean");
// Execute the public
// method of the bean
testObject.foo();
}
}
要對一個BusinessLogic類的實例徹底重寫對foo()方法的調用，需要創建around通知，如下面的AroundAdvice類所示：
import org.aopalliance.intercept.MethodInvocation;
import org.aopalliance.intercept.MethodInterceptor;
public class AroundAdvice
implements MethodInterceptor
{
public Object invoke(
MethodInvocation invocation)
throws Throwable
{
System.out.println(
"Hello world! (by " +
this.getClass().getName() +
")");
return null;
}
}
要在Spring中用作around通知，AroundAdvice類必須實現MethodInterceptor接口和它的invoke(..)方法。每當截獲到方法的重寫，invoke(..)方法就會被調用。最后一步是改變包含在應用程序的springconfig.xml文件中的Spring運行時配置，以便可以對應用程序應用AroundAdvice。
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<!-- Bean configuration -->
<bean id="businesslogicbean"
class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>IBusinessLogic</value>
</property>
<property name="target">
<ref local="beanTarget"/>
</property>
<property name="interceptorNames">
<list>
<value>theAroundAdvisor</value>
</list>
</property>
</bean>
<!-- Bean Classes -->
<bean id="beanTarget"
class="BusinessLogic"/>
<!-- Advisor pointcut definition for around advice -->
<bean id="theAroundAdvisor"
class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice">
<ref local="theAroundAdvice"/>
</property>
<property name="pattern">
<value>.*</value>
</property>
</bean>
<!-- Advice classes -->
<bean id="theAroundAdvice"
class="AroundAdvice"/>
</beans>
根據該springconfig.xml配置文件，theAroundAdvisor截獲所有對BusinessLogic類的方法的調用。接下來，theAroundAdvisor被關聯到theAroundAdvice，表明當截獲一個方法時，就應該使用在AroundAdvice類中指定的通知。既然已經指定了around通知的正確配置，下一次執行MainApplication類時，BusinessLogic bean的foo()方法就會被截獲并重寫，如圖3所示：
圖3. 使用around通知重寫對BusinessLogic類中的foo()方法的調用
前面的例子顯示，BusinessLogic類中的foo()方法可以通過AroundAdvice類中的invoke(..)方法徹底重寫。原來的foo()方法完全不能被invoke(..)方法調用。如果希望從around通知內調用foo()方法，可以使用proceed()方法，可從invoke(..)方法的MethodInvocation參數中得到它。
public class AroundAdvice
implements MethodInterceptor
{
public Object invoke(
MethodInvocation invocation)
throws Throwable
{
System.out.println(
"Hello world! (by " +
this.getClass().getName() +
")");
invocation.proceed();
System.out.println("Goodbye! (by " +
this.getClass().getName() +
")");
return null;
}
}
圖4顯示了對proceed()的調用如何影響操作的順序（與圖3所示的初始around通知執行相比較）。
圖4. 從around通知內使用proceed()調用原來的方法
當調用proceed()時，實際是在指示被截獲的方法（在本例中是foo()方法）利用包含在MethodInvocation對象中的信息運行。您可以通過調用MethodInvocation類中的其他方法來改變該信息。
您可能希望更改包含在MethodInvocation類中的信息，以便在使用proceed()調用被截獲的方法之前對被截獲方法的參數設置新值。
通過對MethodInvocation對象調用getArguments()方法，然后在返回的數組中設置其中的一個參數對象，最初傳遞給被截獲的方法的參數可以被更改。
如果IbusinessClass和BusinessLogic類的foo()方法被更改為使用整型參數，那么就可以將傳遞給被截獲的調用的值由在AroundAdvice的notify(..)方法中傳遞改為在foo(int)中傳遞。
public class AroundAdvice
implements MethodInterceptor
{
public Object invoke(
MethodInvocation invocation)
throws Throwable
{
System.out.println(
"Hello world! (by " +
this.getClass().getName() +
")");
invocation.getArguments()[0] = new Integer(20);
invocation.proceed();
System.out.println(
"Goodbye! (by " +
this.getClass().getName() +
")");
return null;
}
}
在本例中，被截獲的方法的第一個形參被假設為int。實參本身是作為對象傳遞的，所以通過將其包裝在Integer類實例中的方法，基本的int類型的形參被改為對應數組中的新值。如果您將該參數設置為一個非Integer對象的值，那么在運行時就會拋出IllegalArgumentException異常。
您還將注意到，invoke(..)方法必須包含一個return語句，因為該方法需要返回值。但是，被重寫的foo()方法并不返回對象，所以invoke(..)方法可以以返回null結束。如果在foo()方法不需要的情況下，您仍然返回了一個對象，那么該對象將被忽略。
如果foo()方法確實需要返回值，那么需要返回一個與foo()方法的初始返回類型在同一個類或其子類中的對象。如果foo()方法返回一個簡單類型，例如，一個integer，那么您需要返回一個Integer類的對象，當方法被重寫時，該對象會自動由AOP代理拆箱，如圖5所示：
圖5. around通知的裝箱和自動拆箱
圖字：
Object invoke：對象調用
The integer return value is boxed in a Integer object in the AroundAdvice and then unboxed by the AOP Proxy：整型返回值被裝箱在AroundAdvic通知的一個Integer對象中，然后由AOP代理拆箱。
面向方面編程還是一個比較新的領域，尤其是與衍生出它的面向對象編程相比。設計模式通常被認為是常見問題的通用解決方案，因為面向方面發展的時間還不長，所以已發現的面向方面設計模式比較少。
此處要介紹的是一種正在浮現的模式，即Cuckoo's Egg設計模式。該模式還有其他的叫法，它在面向對象領域的對等體包括模仿對象（Mock Object）和模仿測試（Mock Testing），甚至代理模式也與它有一些類似之處。
Cuckoo's Egg面向方面設計模式可以被定義為應用程序上下文中功能部件的透明和模塊化的置換。就像杜鵑偷偷地把自己的蛋放在另一種鳥的巢中一樣，Cuckoo's Egg設計模式用一個替代功能部件實現置換現有的功能部件,而使造成的干擾盡可能少。
這種置換的實現方式可以是靜態的、動態的、部分的、完全的，針對一個對象的多個部分，或針對多個組件。使用面向方面的方法可以透明地實現功能部件的置換，而無需對應用程序的其余部分進行更改。要置換應用程序中現有功能部件的替代功能部件就是“杜鵑的蛋”。圖6顯示了Cuckoo's Egg設計模式中的主要組成元素。
圖6. Cuckoo's Egg設計模式中的主要組成元素
圖字：
Application：應用程序
Component：組件
Replacement Feature：替代功能部件
Component 1 and 2 together encompass a distinct feature of the software：組件1和2共同包含了軟件的一個獨立的功能部件
The Cuckoo's Egg pattern transparently replaces an existing feature of the software：Cuckoo's Egg模式透明地置換了軟件現有的功能部件
Before the pattern is applied：應用該模式前
After the pattern is applied：應用該模式后
Cuckoo's Egg設計模式依賴于around通知的概念。您需要借助于積極的和侵入性的around通知來截獲并有效置換應用程序中現有的功能部件。
有關Cuckoo's Egg設計模式的更多信息，以及AspectJ中的一個可選實現，請參見《AspectJ Cookbook》（O'Reilly，2004年12月出版）。
要使用Spring AOP實現Cuckoo's Egg設計模式，需要聲明一個around通知來截獲所有對要置換的功能部件的調用。與hot-swappable target sources（Spring AOP的一個功能部件，將在本系列的另一篇文章中介紹）不同，around通知的顯式使用使得Cuckoo's Egg實現可以有效地跨越對象邊界（因此也可以跨越bean邊界）進行整個功能部件的置換，如圖7所示。
圖7. 一個跨越bean邊界的組件
圖字：
A feature crosses the boundaries of BusinessLogic and BusinessLogic2 by depending on behavior supplied separately by the two beans：一個功能部件通過依賴于由BusinessLogic和BusinessLogic2各自提供的行為而跨越了這兩個bean的邊界
下面的代碼顯示了一個具有兩個bean的簡單應用程序，其中有一個功能部件跨越了該應用程序的多個方面。要置換的功能部件可以被視為包含IBusinessLogic bean中的foo()方法和IBusinessLogic2 bean中的bar()方法。IBusinessLogic2 bean中的baz()方法不是 該功能部件的一部分，所以不進行置換。
public interface IBusinessLogic
{
public void foo();
}
public interface IBusinessLogic2
{
public void bar();
public void baz();
}
該例子的完整源代碼可在本文末尾的參考資料小節中下載。
此處，ReplacementFeature類扮演了“杜鵑的蛋”的角色，它提供了將被透明地引入應用程序的替代實現。ReplacementFeature類實現了所有在該類引入時要被置換的方法。
public class ReplacementFeature
{
public void foo()
{
System.out.println(
"Inside ReplacementFeature.foo()");
}
public void bar()
{
System.out.println(
"Inside ReplacementFeature.bar()");
}
}
現在需要聲明一個around通知來截獲對跨越bean的功能部件的方法調用。CuckoosEgg類提供了某種around通知來檢查被截獲的方法，并將適當的方法調用傳遞給ReplacementFeature類的實例。
public class CuckoosEgg implements MethodInterceptor
{
public ReplacementFeature replacementFeature =
new ReplacementFeature();
public Object invoke(MethodInvocation invocation)
throws Throwable
{
if (invocation.getMethod().getName().equals("foo"))
{
replacementFeature.foo();
}
else
{
replacementFeature.bar();
}
return null;
}
}
因為與Spring框架關系密切，Cuckoo's Egg設計的詳細信息被放在springconfig.xml配置文件中。對springconfig.xml文件的更改將確保所有對IbusinessLogic和IBusinessLogic2 bean的foo()方法和bar()方法的調用都將被截獲，并傳遞給CuckoosEgg類的around通知。
...
<!--CONFIG-->
<bean id="businesslogicbean"
class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>IBusinessLogic</value>
</property>
<property name="target">
<ref local="beanTarget"/>
</property>
<property name="interceptorNames">
<list>
<value>theCuckoosEggAdvisor</value>
</list>
</property>
</bean>
<bean id="businesslogicbean2"
class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>IBusinessLogic2</value>
</property>
<property name="target">
<ref local="beanTarget2"/>
</property>
<property name="interceptorNames">
<list>
<value>theCuckoosEgg2Advisor</value>
</list>
</property>
</bean>
<!--CLASS-->
<bean id="beanTarget" class="BusinessLogic"/>
<bean id="beanTarget2" class="BusinessLogic2"/>
<!--ADVISOR-->
<bean id="theCuckoosEggAdvisor"
class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice">
<ref local="theReplacementFeaturePart1Advice"/>
</property>
<property name="pattern">
<value>IBusinessLogic.*</value>
</property>
</bean>
<bean id="theCuckoosEgg2Advisor"
class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice">
<ref local="theReplacementFeaturePart2Advice"/>
</property>
<property name="pattern">
<value>IBusinessLogic2.bar*</value>
</property>
</bean>
<!--ADVICE-->
<bean id="theReplacementFeaturePart1Advice" class="CuckoosEgg"/>
<bean id="theReplacementFeaturePart2Advice" class="CuckoosEgg"/>
...
當使用修改后的springconfig.xml文件運行例子應用程序時，要替換的、被指定為功能部件的一部分的方法調用完全被截獲并傳遞給ReplacementFeature類。
通常，即使在同一個實現環境中，我們也可以用不同的方法來實現同一種設計模式。實現上例的另一種方法是實現兩個獨立的通知。
最后需要注意的是，使用Cuckoo's Egg設計模式置換的功能部件，不管它是跨越bean的還是在一個類中，它的生命周期與它所置換的功能部件的目標生命周期匹配。在上例中這沒什么問題，因為只有一個功能部件實例被置換了，而且唯一的Cuckoo's Egg通知只維護一個替代功能部件。
這個例子非常簡單，而在實踐中，您很可能必須處理大量需要用各自的Cuckoo's Egg實例置換的功能部件實例。在這種情況下，單個的方面實例需要被關聯到單個的要置換的功能部件實例。本系列的下一篇文章將會考慮方面生命周期的用法，屆時將解決這個問題。
結束語
本文介紹了如何在Spring框架內謹慎使用around形式的通知。around形式的通知常用于實現Cuckoo's Egg設計模式時，所以我們引入了一個例子來說明如何使用Spring AOP實現這種面向方面設計模式。
在本系列的第三部分中，您將看到如何使用Spring框架中其他的AOP基本概念。這些概念包括：控制方面生命周期、使用基于introduction通知的積極方面改變應用程序的靜態結構，以及使用control flow切入點實現對方面編織的更細微的控制。
參考資料
原文出處
An Introduction to Aspect-Oriented Programming with the Spring Framework, Part 2 http://www.onjava.com/pub/a/onjava/2004/10/20/springaop2.html
| ?作者簡介 |
| Russell Miles是General Dynamics UK公司的一名軟件工程師，他負責Java和分布式系統，但是他目前主要的興趣在面向方面領域，尤其是AspectJ。 |
時間：2005-12-16
作者：
Russell Miles瀏覽次數：
5882
本文關鍵字：
Java,?
Spring,?
aspect-oriented programming,?
AOP,?
crosscutting,?
面向方面編程,?
橫切,?
延遲加載 作為這個介紹Spring框架中的面向方面編程(Aspect-Oriented Programming，AOP)的系列的第一部分，本文介紹了使您可以使用Spring中的面向方面特性進行快速開發的基礎知識。使用跟蹤和記錄方面（面向方面領域的HelloWorld）作為例子，本文展示了如何使用Spring框架所獨有的特性來聲明切入點和通知以便應用方面。本系列的第二部分將更深入地介紹如何運用Spring中的所有通知類型和切入點來實現更實用的方面和面向方面設計模式。對于AOP的更一般性的介紹，請查看ONJava站點上Graham O'Regan的文章，“Introduction to Aspect-Oriented Programming”。
本文的目的不是要介紹構成模塊化J2EE系統——即Spring框架——的所有重要元素，我們將只把注意力放在Spring所提供的AOP功能上。由于Spring的模塊化設計方法，我們可以只使用該框架的AOP元素，而無需對構成Spring框架的其他模塊做太多考慮。
在AOP方面，Spring提供了什么？
“它的目標不是提供最完善的AOP實現（雖然Spring AOP非常強大）；而是要提供AOP實現與Spring IoC的緊密集成，以便幫助解決企業應用中的常見問題。”
Spring Framework參考文檔
為了實現這個目標，Spring框架目前支持一組AOP概念，從切入點到通知。本文將展示如何使用Spring框架中所實現的如下AOP概念：
- 通知（Advice）：如何將before通知、afterReturning通知和afterThrowing通知聲明為bean。
- 切入點（Pointcut）：如何聲明靜態切入點邏輯以將XML Spring Bean Configuration文件中的所有內容聯系在一起。
- Advisor：關聯切入點定義與通知bean的方式。
設置場景：一個簡單的例子應用程序
“一般而言，Spring并不是預描述的。雖然使用好的實踐非常容易，但是它避免強制推行一種特定的方法?！?br />Spring Framework參考文檔
要試用Spring框架的AOP功能，首先我們要創建一個簡單的Java應用程序。IbusinessLogic接口和BusinessLogic類為Spring框架中的bean提供了簡易構件塊。雖然該接口對于我們的簡單應用程序邏輯來說不是必需的，但是它是Spring框架所推薦的良好實踐。
public interface IBusinessLogic
{
public void foo();
}
public class BusinessLogic
implements IBusinessLogic
{
public void foo()
{
System.out.println(
"Inside BusinessLogic.foo()");
}
}
可以編寫MainApplication類，借此練習BusinessLogic bean的公有方法。
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class MainApplication
{
public static void main(String [] args)
{
// Read the configuration file
ApplicationContext ctx =
new FileSystemXmlApplicationContext(
"springconfig.xml");
//Instantiate an object
IBusinessLogic testObject =
(IBusinessLogic) ctx.getBean("businesslogicbean");
// Execute the public
// method of the bean
testObject.foo();
}
}
在BusinessLogic類及其關聯接口中沒有什么需要注意的。但是，MainApplication類初始化BusinessLogic對象的方式很有意思。通過使用ctx.getBean("businesslogicbean")調用，MainApplication將加載和管理BusinessLogic類的bean實例的任務轉交給了Spring框架。
允許Spring控制BusinessLogic bean的初始化，這使得Spring運行時有機會在bean被返回給應用程序之前執行J2EE系統所需的所有與bean相關的管理任務。然后Spring運行時配置可以決定對bean應用哪些任務和模塊。該配置信息由一個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 configuration -->
<bean id="businesslogicbean"
class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>IBusinessLogic</value>
</property>
<property name="target">
<ref local="beanTarget"/>
</property>
</bean>
<!-- Bean Classes -->
<bean id="beanTarget"
class="BusinessLogic"/>
</beans>
該配置文件，即springconfig.xml，指定要加載一個接口與IbusinessLogic相匹配的bean。該bean隨后被關聯到BusinessLogic實現類?？雌饋砗孟袷琴M了很大力氣只為了加載一個簡單的bean并調用一個方法，但是您要知道，這個配置文件只是使Spring框架可以透明地對應用程序應用其組件的眾多特性的一個體現。
圖1顯示了基本的順序圖：MainApplication原樣執行，沒有應用方面。
圖1.沒有對BusinessLogic bean應用方面時的順序圖
請查看本文末尾處的參考資料，獲取這個簡單Spring應用程序的源代碼。
應用方法跟蹤（Method Tracing）方面
可能最基本的方面就是方法跟蹤方面了。這可能是您找得到的最簡單的方面了，因此它是研究新的AOP實現的一個很好的起點。
方法跟蹤方面在一個目標應用程序內捕獲對所跟蹤的方法的調用以及方法的返回值，并以某種方式顯示這種信息。在AOP中，通知的before和after類型用于捕獲這些類型的聯結點，因為這兩種通知可以在方法調用聯結點之前或之后觸發。使用Spring框架，方法跟蹤方面的before通知是在TracingBeforeAdvice類中聲明的。
import java.lang.reflect.Method;
import org.springframework.aop. MethodBeforeAdvice;
public class TracingBeforeAdvice
implements MethodBeforeAdvice
{
public void before(Method m,
Object[] args,
Object target)
throws Throwable
{
System.out.println(
"Hello world! (by " +
this.getClass().getName() +
")");
}
}
類似地，after通知可以在TracingAfterAdvice類中聲明。
import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
public class TracingAfterAdvice
implements AfterReturningAdvice
{
public void afterReturning(Object object,
Method m,
Object[] args,
Object target)
throws Throwable
{
System.out.println(
"Hello world! (by " +
this.getClass().getName() +
")");
}
}
這兩個類都通過實現Spring框架的適當通知接口而表示了特定的通知。每種類型的通知都指定實現before(..)或afterReturning(..)方法，以便使Spring運行時可以告訴通知適當的聯結點會在何時出現。值得注意的是，TracingAfterAdvice實際上是從AfterReturningAdvice擴展而來的，表示只有在聯結點在無異常的情況下獲得返回值時才運行通知。
為了將通知與應用程序中的適當聯結點關聯起來，必須對springconfig.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 configuration -->
<bean id="businesslogicbean"
class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>IBusinessLogic</value>
</property>
<property name="target">
<ref local="beanTarget"/>
</property>
<property name="interceptorNames">
<list>
<value>theTracingBeforeAdvisor</value>
<value>theTracingAfterAdvisor</value>
</list>
</property>
</bean>
<!-- Bean Classes -->
<bean id="beanTarget"
class="BusinessLogic"/>
<!-- Advisor pointcut definition for before advice -->
<bean id="theTracingBeforeAdvisor"
class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice">
<ref local="theTracingBeforeAdvice"/>
</property>
<property name="pattern">
<value>.*</value>
</property>
</bean>
<!-- Advisor pointcut definition for after advice -->
<bean id="theTracingAfterAdvisor"
class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
<property name="advice">
<ref local="theTracingAfterAdvice"/>
</property>
<property name="pattern">
<value>.*</value>
</property>
</bean<
<!-- Advice classes -->
<bean id="theTracingBeforeAdvice"
class="TracingBeforeAdvice"/>
<bean id="theTracingAfterAdvice"
class="TracingAfterAdvice"/>
</beans>
theTracingBeforeAdvisor和theTracingAfterAdvisor advisor被添加到前面所聲明的businesslogicbean。每個advisor都可能截獲所有bean所關聯到的聯結點。Advisor本身就是bean，而它唯一的作用就是將切入點定義與通知bean關聯起來。本例中的切入點定義是在靜態對象層次結構中指定相關聯結點的正則表達式。
因為本例中使用了org.springframework.aop.support.RegexpMethodPointcutAdvisor切入點advisor，切入點邏輯是使用正則表達式指定的。正則表達式用于識別公有接口對IbusinessLogici接口的聯結點。下面是一些可以用來指定IBusinessLogic接口上的不同聯結點集合的正則表達式例子：
- <value>.*</value>：該表達式選擇advisor所關聯到的一個或多個bean上的所有聯結點。
- <value>./IBusinessLogic/.foo</value>：該表達式只選擇IbusinessLogic接口上的foo()方法的聯結點。如果是advisor所關聯到的bean，則該表達式只選擇IBusinessLogic接口上的聯結點。
springconfig.xml文件中最后的bean聲明指定實現通知bean的類。
既然已經指定了跟蹤方面的正確配置，那么下一次執行MainApplication時，這些方面就會在初始化過程中被編織進去，而BusinessLogic bean中的所有方法都將被跟蹤，如圖2所示。
圖2. 方法跟蹤方面應用到BusinessLogic bean之后的順序圖（單擊圖像查看大圖）
方法跟蹤方面和例子應用程序的源代碼可在本文末尾的參考資料小節進行下載。
方面的重用
可以對方法跟蹤方面進行擴展，提供一個稍微復雜的記錄（Logging）方面。記錄方面提供了一個很不錯的重用例子，因為記錄方面所需的許多特性都已經包含在方法跟蹤方面中了。
在本例中，記錄方面擴展了方法跟蹤方面，以便顯示附加的與（在應用程序的執行過程中）所引發的異常有關的信息。
要完全使用記錄方面，需要對應用程序做一些更改。BusinessLogicException異常類提供了一個可以由IBusinessLogicInterface接口和BusinessLogic實現類新增的void bar()方法引發的異常。
public class BusinessLogicException
extends Exception
{
}
public interface IBusinessLogic
{
public void foo();
public void bar()
throws BusinessLogicException;
}
public class BusinessLogic
implements IBusinessLogic
{
public void foo()
{
System.out.println(
"Inside BusinessLogic.foo()");
}
public void bar()
throws BusinessLogicException
{
System.out.println(
"Inside BusinessLogic.bar()");
throw new BusinessLogicException();
}
}
MainApplication類現在將對void bar()方法進行一次額外的調用，并處理選中的、可能由該方法引發的異常。
import org.springframeworkcontext.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class MainApplication
{
public static void main(String [] args)
{
// Read the configuration file
ApplicationContext ctx =
new FileSystemXmlApplicationContext(
"springconfig.xml");
//Instantiate an object
IBusinessLogic testObject =
(IBusinessLogic) ctx.getBean(
"businesslogicbean");
//Execute the public methods of the bean
testObject.foo();
try
{
testObject.bar();
}
catch(BusinessLogicException ble)
{
System.out.println(
"Caught BusinessLogicException");
}
}
}
來自方法跟蹤方面的TracingBeforeAdvice和TracingAfterAdvice通知可以整體重用。LoggingThrowsAdvice類為新的異常記錄提供了通知。
import org.springframework.aop.ThrowsAdvice;
import java.lang.reflect.Method;
public class LoggingThrowsAdvice
implements ThrowsAdvice
{
public void afterThrowing(Method method,
Object[] args,
Object target,
Throwable subclass)
{
System.out.println(
"Logging that a " +
subclass +
"Exception was thrown.");
}
}
應用記錄方面的最后一步是修改springconfig.xml配置文件，使其包含新添加的LoggingThrowsAdvice通知。
圖3顯示了運行MainApplication并使用Spring框架應用了記錄方面的UML順序圖。
圖3. 記錄方面應用到BusinessLogic bean之后的順序圖（單擊圖像查看大圖）
此處的記錄方面清楚地說明了如何重用現有方面以及如何在Spring框架中使用通知的throws形式。通過為before和after通知聲明新的通知來重寫現有的方法跟蹤方面實現，可以實現更復雜的記錄方面，記錄到更復雜的記錄框架，比如LOG4J。關于記錄方面和例子應用程序的源代碼，請參見本文末尾的參考資料小節。
結束語
本文展示了使用Spring框架中的基本AOP結構所應用的一些簡單方面。在本系列的下一篇文章中，我們將介紹一些更實用的方面，探討方面的生命周期，使用Spring框架的around通知，并使用Spring來應用AOP模式。
參考資料
原文出處:An Introduction to Aspect-Oriented Programming with the Spring Framework, Part 1http://www.onjava.com/pub/a/onjava/2004/07/14/springaop.html
| ?作者簡介 |
| Russell Miles是General Dynamics UK公司的一名軟件工程師，他負責Java和分布式系統，但是他目前主要的興趣在面向方面領域，尤其是AspectJ。 |
在本文中，作者通過一個Web Service訪問的實例，具體描述了SOA應用中所遇到的一系列具體問題，并描述如何利用IoC和AOP等技術進行代碼重構，從而構建結構更加良好、靈活的SOA應用。
1.引言
SOA是一種構造分布式系統的方法，它將業務應用功能以服務的形式提供出來，以便更好的復用、組裝和與外部系統集成，從而降低開發成本，提高開發效率。SOA的目標是為企業構建一個靈活，可擴展的IT基礎架構來更好地支持隨需應變的商務應用。
隨著SOA技術和產品的不斷成熟，現在越來越多的用戶開始了解并認同SOA的理念，但對SOA項目的實施還缺乏信心。其主要原因是：SOA應用開發還相對比較復雜。
一年多來，本文作者所在的部門已經從事了許多國內外的SOA項目的實施和支持工作，積累了許多SOA應用開發經驗。我們希望能夠通過一系列的文章與讀者分享這些想法，幫助您更好地構建SOA應用。
本文將從Web Service調用入手，在解決一系列具體問題的過程中，使用IoC (Inversion of Control) 和AOP (Aspect- Oriented Programming) 等方法重構Web Service的訪問代碼，使得業務邏輯與Web Service訪問解耦，為您提供一個更加靈活和易于擴展的訪問模式。
Spring是一個流行的輕量級容器，對IoC和AOP提供了良好的支持。本文為您提供了一個基于Spring的實現供您下載學習。示例代碼工程使用Eclipse3.1/3.02和JDK1.4開發, 您還需要Spring 1.2.5和Axis1.3提供的支持。詳細的下載信息請參見參考資源部分。
2.Web Service調用
Web Service是目前實現SOA應用的一項基本的，適用的技術，它為服務的訪問提供了一個被廣泛接受的開放標準。為了便于說明問題，我們將使用XMethods 網站（http://www.xmethods.net/）發布的貨幣兌換服務作為示例。并針對JAX-RPC 1.1，說明如何編寫Web Service 的調用代碼。
2.1 示例說明
http://xmethods.net 作為最早推出Web Service實際示例的網站，提供了很多優秀的Web Service 樣例。其中有一個匯率計算服務，可以返回兩個國家之間的貨幣兌換比例。獲取該服務的詳細信息，請參考該服務的服務描述文檔（獲取WSDL 文檔） 。在此就不具體解析該服務描述文檔了。讀者可以從WSDL2Java生成的接口中了解該服務的用法：
public interface CurrencyExchangePortType extends java.rmi.Remote {
public float getRate(String country1, String country2) throws java.rmi.RemoteException;
}
|
2.2 客戶端調用方法
JAX-RPC作為Java平臺的RPC服務調用標準接口，為Web Service客戶端調用提供了3種方法，分別是DII，動態代理，和靜態Stub。 DII（Dynamic Invocation Interface）采用直接調用方式，可以在程序中設置諸多的調用屬性，使用較為靈活，但是調用過程卻相對繁瑣復雜，易造成代碼膨脹且可重用性低，每次調用不同的Web Service都要重復進行大量編碼。
JAX-RPC中動態代理（Dynamic Proxy）的方法實現對Web Service的動態調用，可以在運行時根據用戶定義的Client端接口創建適配對象。從而避免了直接操作底層的接口，減少了客戶端的冗余，屏蔽了調用相關的復雜性。
使用靜態Stub和Service Locator是目前最常用的調用方式。JAX-RPC使用靜態的Stub方式包裝對底層接口的調用，從而提供一種更為簡便的調用方式。使用該方式需要利用支持環境（比如Axis）所提供的工具根據WSDL預生成Web Service客戶端的實現代碼。因此如果服務的WSDL發生變化，就必須重新生成新的客戶端代碼并進行重新部署。
為了更詳細的了解靜態Stub的調用方式，您可以將示例代碼的WebServiceClient.jar導入到您現有Eclipse工作區之中。
客戶端生成代碼包括如下4個類：如圖 1 所示：
圖 1： 客戶端代碼類圖
在上圖中包括的幾個類中：
CurrencyExchangePortType：服務端點接口，定義了Web Service的方法簽名。
CurrencyExchangeService：Service接口，定義了獲取服務端點接口的方法。
CurrencyExchangeServiceLocator：ServiceLocator類，實現了Service接口。
CurrencyExchangeBindingStub： Stub實現類，實現了服務端點接口，封裝了對Web Service訪問的底層邏輯。
使用Stub調用Web Service的過程也非常簡單，讀者可以參考清單 1：
清單 1：Web Service 調用代碼示例
try {
//創建ServiceLocator
CurrencyExchangeServiceLocator locator = new
CurrencyExchangeServiceLocator();
//設定端點地址
URL endPointAddress = new URL("http://services.xmethods.net:80/soap");
//創建Stub實例
CurrencyExchangePortType stub =
locator.getCurrencyExchangePort(endPointAddress);
//設定超時為120秒
((CurrencyExchangeBindingStub)stub).setTimeout(120000);
//調用Web Service計算人民幣與美元的匯率
float newPrice = stub.getRate("China", "USA") * 100;
} catch (MalformedURLException mex) {
//...
} catch (ServiceException sex) {
//...
} catch (RemoteException rex) {
//...
}
|
3.重構Web Service調用代碼
3.1 實例代碼中的"壞味道"
上面的基于Service Locator的Web Service訪問代碼雖然簡單但暴露出以下幾個問題：
1．訪問Web Service所需的配置代碼被嵌入應用邏輯之中
在Web Service調用中，我們需要設定一系列必要的參數。比如：服務端點地址、用戶名/密碼、超時設定等等。這些參數在開發和運行環境中都有可能發生變化。我們必須提供一種機制：在環境變化時，不必修改源代碼就可以改變Web Service的訪問配置。
2 客戶端代碼與Web Service訪問代碼綁定
在上面的代碼中，業務邏輯與Web Service的Stub創建和配置代碼綁定在一起。這也不是一種良好的編程方式。客戶端代碼只應關心服務的接口，而不應關心服務的實現和訪問細節。比如，我們既可以通過Web Service的方式訪問遠程服務，也可以通過EJB的方式進行訪問。訪問方式對業務邏輯應該是透明的。
這種分離客戶端代碼與服務訪問代碼的方式也有利于測試。這樣在開發過程中，負責集成的程序員就可能在遠程服務還未完全實現的情況下，基于服務接口編寫集成代碼，并通過編寫POJO（Plain Old Java Object）構建偽服務實現來進行單元測試和模擬運行。這種開發方式對于保證分布式系統代碼質量具有重要意義。
因此，為了解決上面的問題我們需要：
1、將Web Service訪問的配置管理與代碼分離；
2、解除客戶端代碼與遠程服務之間的依賴關系；
3.2 利用IoC模式進行重構代碼
我們先介紹在Core J2EE Patterns一書中提到的一種業務層模式：Business Delegate。它所要解決的問題是屏蔽遠程服務訪問的復雜性。它的主要思想就是將Business Delegate作為遠程服務的客戶端抽象，隱藏服務訪問細節。Business Delegate還可以封裝并改變服務調用過程，比如將遠程服務調用拋出的異常（例如RemoteException）轉換為應用級別的異常類型。
其類圖如圖 2 所示：
圖 2：Business Delegate 模式的類圖圖解
Business Delegate模式實現很好地實現了客戶端與遠程訪問代碼的解耦，但它并不關注Delegate與遠程服務之間的解耦。為了更好解決Business Delegate和遠程服務之間的依賴關系，并更好地進行配置管理，我們可以用IoC模式來加以解決。
IoC（Inversion of Contro）l意為控制反轉，其背后的概念常被表述為"好萊塢法則"："Don't call me, I'll call you." IoC將一部分責任從應用代碼交給framework（或者控制器）來做。通過IoC可以實現接口和具體實現的高度分離，降低對象之間的耦合程度。Spring是一個非常流行的IoC容器，它通過配置文件來定義對象的生命周期和依賴關系，并提供了良好的配置管理能力。
現在我們來重構我們的Web Service應用程序，我們首先為Business Delegate定義一個接口類型，它提供了一個應用級組件接口，所有客戶端都應通過它來執行匯率計算，而不必關心實現細節，如清單 2 所示：
清單 2：接口定義的代碼示例
Public interface CurrencyExchangeManager {
//貨幣兌換計算
//新價格 = 匯率 * 價格
public float calculate(String country1, String country2, float price)
throws CurrencyExchangeException;
}
|
Business Delegate的實現非常簡單，主要工作是包裝匯率計算 Web Service的調用，如清單 3 所示。
清單 3：Business Delegate的代碼示例
public class CurrencyExchangeManagerImpl implements CurrencyExchangeManager {
//服務實例
private CurrencyExchangePortType stub;
//獲取服務實例
public CurrencyExchangePortType getStub() {
return stub;
}
//設定服務實例
public void setStub(CurrencyExchangePortType stub) {
this.stub = stub;
}
//實現貨幣兌換
public float calculate(String country1, String country2, float price)
throws CurrencyExchangeException {
try {
//通過Stub調用WebService
float rate = stub.getRate(country1, country2);
return rate * price;
} catch (RemoteException rex) {
throw new CurrencyExchangeException(
"Failed to get exchange rate!", rex);
}
}
}
|
下面我們需要討論如何利用Spring的IoC機制，來創建和配置對象，并定義它們的依賴關系。
Spring利用類工廠來創建和配置對象。在Spring框架中，已經為基于JAX－RPC的Web Service調用提供了一個客戶端代理的類工廠實現：JaxRpcPortProxyFactoryBean。在配置文件bean.xml中，我們將使用JaxRpcPortProxyFactoryBean來創建和配置Web Service的客戶端代理"CurrencyExchangeService"，如清單 5 所示。我們還將定義一個名為"CurrencyExchangeManager"的CurrencyExchangeManagerImpl實例，并建立它與CurrencyExchangeService之間的依賴關系。有關Spring 配置和JaxRpcPortProxyFactoryBean的使用細節請參見參考資料。
清單 5：bean.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="CurrencyExchangeService"
class="org.springframework.remoting.jaxrpc.JaxRpcPortProxyFactoryBean">
<property name="serviceInterface">
<value>net.xmethods.www.sd.CurrencyExchangeService_wsdl.
CurrencyExchangePortType</value>
</property>
<property name="wsdlDocumentUrl">
<value>http://www.xmethods.net/sd/2001/CurrencyExchangeService.
wsdl</value>
</property>
<property name="namespaceUri">
<value>http://www.xmethods.net/sd/CurrencyExchangeService.
wsdl</value>
</property>
<property name="serviceName">
<value>CurrencyExchangeService</value>
</property>
<property name="portName">
<value>CurrencyExchangePort</value>
</property>
<property name="endpointAddress">
<value>http://services.xmethods.net:80/soap</value>
</property>
</bean>
<bean id="CurrencyExchangeManager"
class="test.ws.CurrencyExchangeManagerImpl">
<property name="stub">
<ref bean="CurrencyExchangeService"/>
</property>
</bean>
</beans>
|
最后我們創建一個測試程序來驗證我們的代碼，如清單6 所示：
清單 6：測試代碼
public class Main {
// For test only
public static void main(String[] args) {
// Spring Framework將根據配置文件創建并配置CurrencyExchangeManager實例
ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");
// 獲取CurrencyExchangeManager實例
CurrencyExchangeManager manager = (CurrencyExchangeManager) ctx
.getBean("CurrencyExchangeManager");
try {
System.out.println(manager.calculate("China", "USA", 100));
System.out.println(manager.calculate("China", "Japan", 200));
System.out.println(manager.calculate("China", "USA", 200));
} catch (Exception ex) {
ex.printStackTrace();
}
}
}
|
此時運行測試客戶端，等待片刻將會看見測試結果，如清單 7 所示：
清單 7：測試結果。
注：該結果會隨著匯率的變化而出現不同的值。
該程序的類圖和順序圖如圖3及圖4所示：
圖 3：示例程序的類圖
從上面的類圖我們可以看到，我們的測試程序（Main.java）通過Spring框架獲取了BusinessDelegate的實例。而且Spring 框架還會根據配置中的依賴關系，在運行時將Web Service的客戶端代理" 注射"到CurrencyExchangeManagerImpl實例中，這就是依賴注入（Dependency Injection）。通過這種方式解決了應用邏輯和BusinessDelegate之間的依賴關系，以及BusinessDelegate的實現與遠程服務之間的依賴關系，如圖 4 所示。
圖 4: 示例程序的順序圖
Spring框架提供的ApplicationContext實現會根據配置文件中的描述信息來實現對象生命周期管理，配置管理以及依賴管理等功能。這一切對于應用程序是透明的，應用程序代碼只依賴接口進行編程，而無需考慮其它復雜問題。無論是Web Service的配置發生變化，或是改用不同的服務實現時，都不會對客戶端應用代碼的產生影響。這很好地實現了業務邏輯與Web Service調用之間的解耦。
3.3 構建自己的 Web Service代理工廠
Spring所提供的JaxRpcPortProxyFactoryBean封裝了構造Web Service客戶端代理的細節，可以通過參數配置來創建Dynamic Proxy和DII類型的Web Service客戶端代理。（如果您希望深入了解其實現細節可以參考org.springframework.remoting.jaxrpc包下的源代碼。）但由于JaxRpcPortProxyFactoryBean需要使用者對WSDL中Port，Service，名空間等概念有深入的了解；而且如果Web Service使用了復雜數據類型，開發人員需要手工定義類型映射代碼。所以JaxRpcPortProxyFactoryBean并不適合Web Service的初學者來使用。
為了進一步簡化Web Service代理的創建，并幫助讀者更好地理解類工廠在Spring框架下的作用。我們提供了一個基于靜態Stub的Web Service客戶端代理工廠實現。其核心代碼非常簡單，就是通過ServiceLocator提供的方法來創建Web Service客戶端代理。
其主要代碼如清單8所示：
清單8：靜態代理工廠的代碼
public class WebServiceStubFactoryBean implements FactoryBean,
InitializingBean {
private Class serviceInterface;
private Class serviceLocator;
private Object stub;
…
public void afterPropertiesSet() throws Exception {
//利用serviceLocator和服務接口創建Web Service客戶端代理
stub = ((javax.xml.rpc.Service)
serviceLocator.newInstance()).getPort(serviceInterface);
//為Stub設定endpointAddress，usernam, 超時等參數
preparePortStub((javax.xml.rpc.Stub) stub);
}
public Object getObject() {
// 返回客戶端代理
return stub;
}
public Class getObjectType() {
// 返回服務接口
return serviceInterface;
}
public boolean isSingleton() {
return true;
}
}
|
我們需要修改配置文件bean.xml中有關Web Service代理創建的部分，讓新的Web Service 代理工廠發揮作用。如清單9所示：
清單9：修改后的bean.xml的配置文件
<bean id="CurrencyExchangeService" class="test.ws.WebServiceStubFactoryBean">
<property name="serviceInterface">
<value>net.xmethods.www.sd.CurrencyExchangeService_wsdl.CurrencyExchangePortType</value>
</property>
<property name="serviceLocator">
<value>net.xmethods.www.sd.CurrencyExchangeService_wsdl.CurrencyExchangeServiceLocator</value>
</property>
<property name="endpointAddress2">
<value>http://services.xmethods.net:80/soap</value>
</property>
<property name="timeout">
<value>120000</value>
</property>
</bean>
|
得益于Spring框架，雖然我們已經替換了對象的類工廠，卻并不需要更改應用代碼。通過Spring框架的IoC機制，我們可以完全使用面向接口的編程方式，而將實現的創建、配置和依賴管理交由Spring在運行時完成。即使實現發生了變化，也不需要改變應用程序結構。
4.新的思考
故事并沒有結束，在開發過程中，我們又遇到了一系列關于Web Service調用的問題。
4.1性能
系統性能是分布式應用中的一個重要問題。許多用戶都擔心由Web Service技術所引入的額外開銷是否會影響到產品的性能。隨著技術的不斷發展，Web Service引擎性能已經有了很大提高，一般來說使用Web Service的系統的性能可以滿足絕大部分應用的需求。但在特定情況下，如果系統性能無法滿足客戶需求，我們首先需要對系統性能進行科學地分析和測定才能定位真正的性能瓶頸。這個問題在上文簡單的示例中并不難解決，只需要在Web Service調用前后加入日志代碼記錄調用時間即可實現。但在實際系統中，比如一個產品目錄的Web Service可能提供數十種查詢方法，而程序中很多組件都會依賴于該服務提供的查詢功能。如果在系統中所有的地方加入性能測定代碼，這個工作就變得非常繁瑣和困難。我們需要用一種更加優雅的解決方式，在增添新功能的同時并不影響系統代碼或結構。
4.2緩存
在項目實踐中，一個有效的改善Web Service系統性能的方法就是利用緩存來減少Web Service的重復調用。在具體實現中我們可以采用客戶端緩存和服務器端緩存等不同方式，他們具有不同的特點和適用范圍。在本文例子中，我們希望實現客戶端緩存來提高系統性能。但由于Web Service業務邏輯的差別，我們希望能夠為特定的Web Service提供特定的緩存策略，而且這些策略應該是能夠被靈活配置的，它們不應于應用程序的邏輯代碼耦合在一起。
4.3故障恢復：
對于Web Service應用，系統的可用性也是一個需要考慮的重要問題。在運行時由于網絡運行環境的復雜性和不確定性，用戶希望能夠對Web Service訪問提供一定的故障恢復機制：比如重試或者訪問備份服務（當系統在調用Web Service失敗后，使用備份Web Service的服務地址來繼續訪問）。這些故障恢復策略應該是可配置的，對應用邏輯透明的。
5.使用AOP解決SOA應用中的Crosscutting Concern
通過對上邊一系列問題的分析，讀者也許會發現這些問題并不是Web Service訪問的核心問題，但會影響系統中許多不同的組件。而且其中一些問題需要我們能夠靈活配置不同的實現策略，因此我們不應該將處理這些問題的代碼與應用代碼混合。
下面我們將利用AOP（Aspect-Oriented Programming）提供的方法來解決上述的問題。AOP是一種新興的方法學，它最基本的概念就是關注隔離（Separation of Concern）。AOP提供了一系列的技術使得我們能夠從代碼中分離那些影響到許多系統模塊的crosscutting concerns，并將他們模塊化為Aspects。AOP的主要目的仍然是解耦，在分離關注點后，才能將關注點的變更控制一定范圍內，增加程序的靈活性，才能使得關注能夠根據需求和環境作出隨時調整。
我們將利用Spring所提供的AOP功能支持來解決以上問題。這里我們只簡單地介紹涉及到的AOP基本概念以及實現，如果您希望更好地了解AOP的概念以及Spring AOP支持的細節請參見參考資料。
- Joinpoint 是程序的運行點。在Spring AOP中，一個Joinpoint對應著一個方法調用。
- Advice 定義了AOP框架在特定的Joinpoint的處理邏輯。Spring AOP框架通過interceptor方式實現了advice，并且提供了多種advice類型。其中最基本的"around advice"會在一個方法調用之前和之后被執行。
下面我們將利用Spring提供的MethodInterceptor來為Web Service調用實現我們的定義的處理邏輯。
5.1 PerformanceMonitorInterceptor
性能測量是AOP最簡單的例子之一，我們可以直接利用Spring提供的實現在bean.xml中聲明我們的WebServicePerformanceMonitorInterceptor。
5.2 CacheInterceptor
為了不引入緩存策略的復雜性，我們只提供了一個利用HashMap的簡單實現：它利用 Web Service的調用參數列表作為HashMap鍵值。在Web Service調用之前，首先檢查緩存中是否擁有與現在參數列表相同的項，如果有則返回緩存的結果，否則調用Web Service并將<參數列表，結果>記錄在HashMap中。在實際應用中，您應該根據具體情況來選擇、構造適合Web Service的業務特性的Cache實現，也可以采用成熟的Cache實現。
在下面代碼實現中有一個生成Web Service調用主鍵的小技巧。因為Web Service引擎要求所有調用參數必須是可序列化的，所以我們可以利用Java提供的序列化功能來實現對象的克隆。如清單10所示：
清單10：SimpleCacheInterceptor的代碼示例
public class SimpleCacheInterceptor implements MethodInterceptor {
private Map cache = new HashMap();
private Object cloneObject(Object obj) throws Exception {
Object newObj = null;
if (obj != null) {
// 通過序列化/反序列化來克隆對象
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bos);
out.writeObject(obj);
out.flush();
out.close();
ObjectInputStream in = new ObjectInputStream(
new ByteArrayInputStream(bos.toByteArray()));
newObj = in.readObject();
}
return newObj;
}
//基于參數列表數組，生成用于HashMap的鍵值
public Object generateKey(Object[] args) throws Exception {
Object[] newArgs = (Object[]) cloneObject(args);
List key = Arrays.asList(newArgs);
return key;
}
//實現使用緩存技術的invoke方法
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
Object result = null;
Object data = null;
Object key = null;
try {
key = generateKey(methodInvocation.getArguments());
data = cache.get(key);
} catch (Exception ex) {
logger.error("Failed to find from the cache", ex);
}
if (data == null) {
//如果Cache中沒有緩存結果，調用服務執行生成用于HashMap的鍵值
result = methodInvocation.proceed();
try {
data = cloneObject(result);
cache.put(key, data);
} catch (Exception ex) {
logger.error("Failed to cache the result!", ex);
}
} else {
result = data;
}
return result;
}
}
|
5.3 FailoverInterceptor
下面代碼提供了一個基于服務備份切換的故障恢復實現，在運行時，如果Interceptor檢測到服務調用由于網絡故障拋出異常時，它將使用備份服務的端點地址并重新調用。如清單11所示：
清單 11： SimpleFailoverInterceptor的代碼示例
public class SimpleFailoverInterceptor implements MethodInterceptor { …
…
//實現支持端點運行時切換的invoke方法
public Object invoke(MethodInvocation methodInvocation) throws Throwable {
Object result = null;
try {
result = methodInvocation.proceed();
} catch (Throwable ex) {
if (isNetworkFailure(ex)) {
//切換服務端點地址
switchEndPointAddress((Stub) methodInvocation.getThis());
result = methodInvocation.proceed();
} else {
throw ex;
}
}
return result;
}
}
|
為了支持備份服務切換的功能，我們在WebServicePortProxyFactoryBean中為填加了配置參數"endpointAddress2"，它會在創建的Web Service客戶端代理對象中記錄備份URL。
我們可以在CurrencyExchangeService加入下列參數來試驗SimpleFailoverInterceptor的功能。其中第一個端點地址為一個錯誤的URL。在第一次調用服務時，SimpleFailoverInterceptor會偵測到網絡故障的發生，并自動切換使用第二個端點地址繼續訪問。如清單12所示：
清單12：配置文件種增加的屬性
<property name="endpointAddress">
<value>http://localhost/wrong_endpoint_address</value>
</property>
<property name="endpointAddress2">
<value>http://services.xmethods.net:80/soap</value>
</property>
|
5.4配置文件和運行結果
現在我們需要在Spring配置文件中，為所有interceptor添加定義，并描述如何為CurrencyExchangeService構建AOP Proxy。需要指出的是，我們要在interceptorName列表中聲明interceptor鏈的調用順序，還要將原有CurrencyExchangeManager引用的stub對象替換為新AOP Proxy。如清單13所示：
清單13：修改后的配置文件片段
<bean id="WebServicePerformanceMonitorInterceptor"
class="org.springframework.aop.interceptor.PerformanceMonitorInterceptor">
<property name="prefix">
<value>Web Service </value>
</property>
<property name="suffix">
<value></value>
</property>
</bean>
<bean id="CacheInterceptor" class="test.ws.SimpleCacheInterceptor"/>
<bean id="FailoverInterceptor" class="test.ws.SimpleFailoverInterceptor"/>
<bean id="CurrencyExchangeProxy"
class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>net.xmethods.www.sd.CurrencyExchangeService_wsdl.
CurrencyExchangePortType</value>
</property>
<property name="target">
<ref local="CurrencyExchangeService"/>
</property>
<property name="interceptorNames">
<list>
<value>WebServicePerformanceMonitorInterceptor</value>
<value>CacheInterceptor</value>
<value>FailoverInterceptor</value>
</list>
</property>
</bean>
<bean id="CurrencyExchangeManager"
class="test.ws.CurrencyExchangeManagerImpl">
<property name="stub">
<ref bean="CurrencyExchangeProxy"/>
</property>
</bean>
|
這里我們通過為AOP 的ProxyFactoryBean為 Web Service Stub創建了一個AOP代理，并且建立了一個Interceptor鏈。這樣在調用Web Service時，Spring框架會依次調用Interceptor執行。實例執行的順序圖將如圖5所示：
圖5系統運行順序圖
5.5 Interceptor與JAX-RPC Handler的關系與區別
SOAP Message Handler是JAX-RPC為用戶自定義Web Service處理過程提供的一種擴展機制。在處理Web Service請求/響應過程中，Web Service 引擎會根據部署描述中的定義，按照一定的次序調用Handler的處理代碼。用戶編寫的Handler實現可以截獲并修改Web Service消息和處理流程，從而實現對Web Service引擎處理行為的定制和增強。
比如，我們可以實現一個服務器端Handler，記錄Web Service在受到請求消息和發出響應消息之間的時間間隔來實現對服務器端業務性能的測定。而且我們只需在部署描述中增加Handler聲明即可，無需修改任何服務器端代碼。
從此可以看出，JAX-RPC Handler與我們在上文中所提供的AOP Interceptor都可以幫助我們的SOA應用程序實現關注分離（Separate Concern）的目標，在不改變應用代碼的同時，增強或改變Web Service服務訪問的功能。雖然我們可以利用它們實現一些類似的功能，但它們具有著不同的特點和適用范圍。
JAX-RPC Handler是Web Service引擎的擴展機制。如果我們需要實現對SOAP消息進行的修改和處理，加入自定義的SOAP Header或對消息內容進行加密，Handler是我們的最佳選擇。而AOP是針對對象級別的擴展機制，它更適合對應用層邏輯進行操作。
比如，我們在上文展示的利用AOP實現的CacheInterceptor，它緩存的是Web Service調用參數和結果。而我們也可以通過JAX-RPC Handler實現一個面向SOAP消息的實現，它將緩存Web Service的請求消息和響應消息。這兩個實現相比，基于AOP的實現更加簡單、直觀、快速、對資源消耗也比較小。而面向SOAP消息的實現則更加靈活，對于不采用RPC方式的Web Service訪問也能提供支持。
所以在具體的實踐過程中，開發人員應該根據具體的需求選擇合適的技術，也可以將這兩種技術結合使用。
6.總結
"分而治之"的方法是人們解決復雜問題的一種常見做法。而IoC、AOP等技術都體現了這種思想。通過更好的切分程序邏輯，使得程序結構更加良好，更加富有彈性，易于變化。也使得開發人員可以更加專注于業務邏輯本身，而將一部分其他邏輯交給容器和框架進行處理。
在本文中，我們通過一個Web Service訪問的實例，具體描述了SOA應用中所遇到的一系列具體問題，并描述如何利用IoC和AOP等技術進行代碼重構，構建更加結構良好、靈活的SOA應用。綜上所述，我們可以看到：
1使用IoC框架來實現對象的生命周期管理、配置管理和依賴管理，可以解除業務邏輯對服務調用的依賴關系；
2 使用AOP方法來解決Web Service調用中的crosscutting concerns，將為系統增加新的功能而不必更改應用程序。
3通過IoC和AOP來屏蔽Web Service訪問的復雜性，使得開發人員可以更加專注于業務邏輯本身，也使得系統更加穩定和富有彈性。
代碼：下載
由于項目需要，需要做一些類似javascript中eval的方法的計算。
找到beanshell感覺很好用，跟大家分享！
請參考beanshell：
http://www.beanshell.org以下是demo：
/**
? * gf測試宏計算
? * @return
? */
?public void testBshInterpreter(){
??Interpreter interpreter= new Interpreter();
??//String bStr="(100>50 && 100<101)";
??try {
?? //1
???interpreter.set("add", interpreter.eval("(100+101)"));
???System.out.println(interpreter.get("add"));
???interpreter.set("boolean", interpreter.eval("(100>101)"));
???System.out.println(interpreter.get("boolean"));
???//2
???Interpreter i = new Interpreter(); // Construct an interpreter
???i.set("foo", 5); // Set variables
???i.set("date", new Date() );?
???Date date = (Date)
???i.get("date"); // retrieve a variable
???// Eval a statement and get the result
???i.eval("bar = foo*10");?
???System.out.println( i.get("bar") );?
??} catch (EvalError e) {
???e.printStackTrace();
??}
??
?}
public class GetCh2Spell
??????? {
??????????? public static int compare(String str1, String str2)
???????????? {
???????????????? int result = 0;
???????????????? String m_s1 = null;
???????????????? String m_s2 = null;
???????????????? try
???????????????? {
???????????????????? m_s1 = new String(str1.getBytes(_FromEncode_), _ToEncode_);
???????????????????? m_s2 = new String(str2.getBytes(_FromEncode_), _ToEncode_);
???????????????? }
???????????????? catch(Exception e)
???????????????? {
???????????????????? return str1.compareTo(str2);
???????????????? }
???????????????? result = chineseCompareTo(m_s1, m_s2);
???????????????? return result;
???????????? }
???????????? public static int getCharCode(String s)
???????????? {
???????????????? if(s == null && s.equals(""))
???????????????????? return -1;
???????????????? byte b[] = s.getBytes();
???????????????? int value = 0;
???????????????? for(int i = 0; i < b.length && i <= 2; i++)
???????????????????? value = value * 100 + b[i];
???????????????? return value;
???????????? }
???????????? public static int chineseCompareTo(String s1, String s2)
???????????? {
???????????????? int len1 = s1.length();
???????????????? int len2 = s2.length();
???????????????? int n = Math.min(len1, len2);
???????????????? for(int i = 0; i < n; i++)
???????????????? {
???????????????????? int s1_code = getCharCode(s1.charAt(i) + "");
???????????????????? int s2_code = getCharCode(s2.charAt(i) + "");
???????????????????? if(s1_code * s2_code < 0)
???????????????????????? return Math.min(s1_code, s2_code);
???????????????????? if(s1_code != s2_code)
???????????????????????? return s1_code - s2_code;
???????????????? }
???????????????? return len1 - len2;
???????????? }
???????????? public static String getBeginCharacter(String res)
???????????? {
???????????????? String a = res;
???????????????? String result = "";
???????????????? for(int i = 0; i < a.length(); i++)
???????????????? {
???????????????????? String current = a.substring(i, i + 1);
???????????????????? if(compare(current, "\u554A") < 0)
???????????????????????? result = result + current;
???????????????????? else
???????????????????? if(compare(current, "\u554A") >= 0 && compare(current, "\u5EA7") <= 0)
???????????????????????? if(compare(current, "\u531D") >= 0)
???????????????????????????? result = result + "z";
???????????????????????? else
???????????????????????? if(compare(current, "\u538B") >= 0)
???????????????????????????? result = result + "y";
???????????????????????? else
???????????????????????? if(compare(current, "\u6614") >= 0)
???????????????????????????? result = result + "x";
???????????????????????? else
???????????????????????? if(compare(current, "\u6316") >= 0)
???????????????????????????? result = result + "w";
???????????????????????? else
???????????????????????? if(compare(current, "\u584C") >= 0)
???????????????????????????? result = result + "t";
???????????????????????? else
???????????????????????? if(compare(current, "\u6492") >= 0)
???????????????????????????? result = result + "s";
???????????????????????? else
???????????????????????? if(compare(current, "\u7136") >= 0)
???????????????????????????? result = result + "r";
???????????????????????? else
???????????????????????? if(compare(current, "\u671F") >= 0)
???????????????????????????? result = result + "q";
???????????????????????? else
???????????????????????? if(compare(current, "\u556A") >= 0)
???????????????????????????? result = result + "p";
???????????????????????? else
???????????????????????? if(compare(current, "\u54E6") >= 0)
???????????????????????????? result = result + "o";
???????????????????????? else
???????????????????????? if(compare(current, "\u62FF") >= 0)
???????????????????????????? result = result + "n";
???????????????????????? else
???????????????????????? if(compare(current, "\u5988") >= 0)
???????????????????????????? result = result + "m";
???????????????????????? else
???????????????????????? if(compare(current, "\u5783") >= 0)
???????????????????????????? result = result + "l";
???????????????????????? else
???????????????????????? if(compare(current, "\u5580") >= 0)
???????????????????????????? result = result + "k";
???????????????????????? else
???????????????????????? if(compare(current, "\u51FB") > 0)
???????????????????????????? result = result + "j";
???????????????????????? else
???????????????????????? if(compare(current, "\u54C8") >= 0)
???????????????????????????? result = result + "h";
???????????????????????? else
???????????????????????? if(compare(current, "\u5676") >= 0)
???????????????????????????? result = result + "g";
???????????????????????? else
???????????????????????? if(compare(current, "\u53D1") >= 0)
???????????????????????????? result = result + "f";
???????????????????????? else
???????????????????????? if(compare(current, "\u86FE") >= 0)
???????????????????????????? result = result + "e";
???????????????????????? else
???????????????????????? if(compare(current, "\u642D") >= 0)
???????????????????????????? result = result + "d";
???????????????????????? else
???????????????????????? if(compare(current, "\u64E6") >= 0)
???????????????????????????? result = result + "c";
???????????????????????? else
???????????????????????? if(compare(current, "\u82AD") >= 0)
???????????????????????????? result = result + "b";
???????????????????????? else
???????????????????????? if(compare(current, "\u554A") >= 0)
???????????????????????????? result = result + "a";
???????????????? }
???????????????? return result;
???????????? }
???????????? public static String getFirstStr(String str)
???????????? {
???????????????? char a = str.charAt(0);
???????????????? char aa[] = {
???????????????????? a
???????????????? };
???????????????? String sss = new String(aa);
???????????????? if(Character.isDigit(aa[0]))
???????????????????? sss = "data";
???????????????? else
???????????????? if(a >= 'a' && a <= 'z' || a >= 'A' && a <= 'Z')
???????????????????? sss = "character";
???????????????? else
???????????????????? sss = getBeginCharacter(sss);
???????????????? return sss;
???????????? }
???????????? private static String _FromEncode_ = "GBK";
???????????? private static String _ToEncode_ = "GBK";
??????? }
|
Hibernate3.0 采用新的基于ANTLR的HQL/SQL查詢翻譯器，在Hibernate的配置文件中，hibernate.query.factory_class屬性用來選擇查詢翻譯器。
（1）選擇Hibernate3.0的查詢翻譯器：
hibernate.query.factory_class= org.hibernate.hql.ast.ASTQueryTranslatorFactory
（2）選擇Hibernate2.1的查詢翻譯器
hibernate.query.factory_class= org.hibernate.hql.classic.ClassicQueryTranslatorFactory
為了使用3.0的批量更新和刪除功能，只能選擇（1）否則不能解釋批量更新的語句。選擇（2）但沒法解釋批量更新語句了。
大批量更新/刪除（Bulk update/delete）
就像已經討論的那樣，自動和透明的 對象/關系 映射（object/relational mapping）關注于管理對象的狀態。 這就意味著對象的狀態存在于內存，因此直接更新或者刪除 (使用 SQL 語句 UPDATE 和 DELETE) 數據庫中的數據將不會影響內存中的對象狀態和對象數據。 不過，Hibernate提供通過Hibernate查詢語言來執行大批 量SQL風格的（UPDATE）和（DELETE） 語句的方法。
UPDATE 和 DELETE語句的語法為： ( UPDATE | DELETE ) FROM? ClassName (WHERE WHERE_CONDITIONS)?。 有幾點說明：
-
在FROM子句（from-clause）中，FROM關鍵字是可選的
-
在FROM子句（from-clause）中只能有一個類名，并且它不能有別名
-
不能在大批量HQL語句中使用連接（顯式或者隱式的都不行）。不過在WHERE子句中可以使用子查詢。
-
整個WHERE子句是可選的。
舉個例子，使用Query.executeUpdate()方法執行一個HQL UPDATE語句：
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
String hqlUpdate = "update Customer set name = :newName where name = :oldName";
int updatedEntities = s.createQuery( hqlUpdate )
.setString( "newName", newName )
.setString( "oldName", oldName )
.executeUpdate();
tx.commit();
session.close();
執行一個HQL DELETE，同樣使用 Query.executeUpdate() 方法 （此方法是為 那些熟悉JDBC PreparedStatement.executeUpdate() 的人們而設定的）
Session session = sessionFactory.openSession();
Transaction tx = session.beginTransaction();
String hqlDelete = "delete Customer where name = :oldName";
int deletedEntities = s.createQuery( hqlDelete )
.setString( "oldName", oldName )
.executeUpdate();
tx.commit();
session.close();
由Query.executeUpdate()方法返回的整型值表明了受此操作影響的記錄數量。 注意這個數值可能與數據庫中被（最后一條SQL語句）影響了的“行”數有關，也可能沒有。一個大批量HQL操作可能導致多條實際的SQL語句被執行， 舉個例子，對joined-subclass映射方式的類進行的此類操作。這個返回值代表了實際被語句影響了的記錄數量。在那個joined-subclass的例子中， 對一個子類的刪除實際上可能不僅僅會刪除子類映射到的表而且會影響“根”表，還有可能影響與之有繼承關系的joined-subclass映射方式的子類的表。
摘要: 第一部分、SQL&PL/SQL[Q]怎么樣查詢特殊字符，如通配符%與_[A]select * from table where name like 'A_%' escape ''[Q]如何插入單引號到數據庫表中[A]可以用ASCII碼處理，其它特殊字符如&也一樣，如insert into t values('i'||chr(39)||'m'); -- chr(39)代表字符'或者用...
閱讀全文
先記下，以后有用得著的時候也好找。
所見即所得(WYSIWYG?-?What?You?See?Is?What?You?Get)
1、
eWebEditor[Mode?In?China]
簡介：
eWebEditor是eWebSoft.com旗下eWeb團隊開發的基于網頁的、所見即所得的在線HTML編輯器。她能夠在網頁上實現許多桌面編輯軟件（如：Word）所具有的強大可視編輯功能；她是一個真正的綠色軟件，不需要在計算機上安裝任何的客戶端軟件；她的易用使得WEB開發人員只要一行代碼即可完成調用。
當前最新版本：Version?3.8?(ASP版、PHP版、JSP版、ASP.NET版)?
對于一般站點來說，eWebEditor已經很不錯了，簡單易上手。
使用方法/接口：
在線演示：
http://ewebeditor.webasp.net/demo.aspMailMagic下載：eWebEditor?Version?2.8.0?修正版及紹文檔
mailmagic://zoDAsdNafHdAAJzazaazvAoxzdDsadxsqdvNaxfAzfNdfxDzxqzqJzoAqiHfoioqaHxHNAnafsoNzJosfxdsDfnxxvdqvNaqnsnindNfdzsiJiaHJsAJAqzAinAHqNaoqHixiiHvAAzdNHHvnqqfxAndiHonqiAzsNdosvavAqiqvaNNJNqsqznovDqNdAvvvondaaNxiDiffdDsainsaqDifnxvJJaJADzAfafdHnJddxzJJiNHvdqqfviDvodiiAziAHxNnHnzAHnzHanvDisaDHDJHqJn
2、
HTMLArea簡介：
HTMLArea?is?a?free,?customizable?online?editor.?It?works?inside?your?browser.?It?uses?a?non-standard?feature?implemented?in?Internet?Explorer?5.5?or?better?for?Windows?and?Mozilla?1.3?or?better?(any?platform),?therefore?it?will?only?work?in?one?of?these?browsers.?
使用方法/接口：
在線演示：
http://www.dynarch.com/demos/htmlarea/MailMagic下載：HTMLArea?release?3.0-rc1
mailmagic://qzsHqHnfAviDiNoqJvvisNHzsziqfzqxnzznosxnoDAvsvdxqfDqoJdiNiJnxAinsanxfznNnnAzoqvxdnqadJnnqsiJaxHsaassdaaaxAzDNxdDNHDzondfoNAJJodnaiqqzzziadsovfdfAJnoxzHAHsadosJsJffaNfHDnNoAxAvAsfnJADdqdvdsazifJNnHsxNxfavfJnzDfisnxzzfNAxfadnnvHDaxJfoqDHAzfNDsDxNNoizoviHNNaJ
3、
FCKeditor簡介：
This?HTML?text?editor?brings?to?the?web?many?of?the?powerful?functionalities?of?desktop?editors?like?MS?Word.?It's?lightweight?and?doesn't?require?any?kind?of?installation?on?the?client?computer.
Because?it?is?Open?Source,?you?may?use?it?however?you?want.?
使用方法/接口：
在線演示：
http://www.fckeditor.net/demo/default.htmlMailMagic下載：FCKeditor?2.2?released
mailmagic://zxsANfJqNosoAAosnqifNHnDNAxNHaadnHfdHJqAqiDNsNqJAqqqHandxADAfJodoDDzzvoqaHsNvDdvJzAJqvsdxqzasdavfsqvzaHfzHzxqaiNvvHifAzDonxqofHxzxaqDszxqfafAJffJdqsDvvNHNqJsvisooxixAAsfodfJanqfANHNzxvqsxoJszAHnNdqzqvNafaavHJovAvvxHxzqsiisHDNfHDiovfffznJxiAdNfDHxnifizDxdqq
4、
TinyMCE簡介：
TinyMCE?is?a?platform?independent?web?based?Javascript?HTML?WYSIWYG?editor?control?released?as?Open?Source?under?LGPL?by?Moxiecode?Systems?AB.?It?has?the?ability?to?convert?HTML?TEXTAREA?fields?or?other?HTML?elements?to?editor?instances.?TinyMCE?is?very?easy?to?integrate?into?other?CMS?systems.?
使用方法/接口：
在線演示：
MailMagic下載：TinyMCE?2.0.4
mailmagic://JiDqnAddiHsJnDHDiiaDDAJiNAvDioAAdqNddoizHindzsDxofniHaxDzxNszxqxvavivHiNzxzisovNqqxaDadzDoaxAJdzdNdxozdfvnxozHHdfJqssaiDzvaiHNiiHdHxqzsJAHsJfdDdxHDqvADvNaJsnJovoDDAfaaDqDoiaasAqnJoAxinvssziiAqJNsxsdfvoxNNdoAoxiiDaanJnfsNAnqDnfxfazssfJssqJJzixvHnDqiaiodJiJq
5、
FreeTextBox簡介：
The?no.1?free?ASP.NET?HTML?Editor?for?IE?and?Mozilla.?
使用方法/接口：
在線演示：
http://www.freetextbox.com/MailMagic下載：FreeTextBox?3.0??Free?License?(free!)
mailmagic://oHNxNdiDzAxxofxiNHizdsaDADzfxoxfJsaNHdzAoaxNAdnaDvxNoxdxnxszqqANDoxJffJNAvixAoNnfiHasAzJJHAaJNJinJDNNioffviooqfHvffnnNHHxfvNfidnAoofdDfsaofAxafJoAJnNfanodovJofHAJzqanfJzqHdzvaJsosixaNaoxHNodfsHzzzdsDnovvJisNqvdqfzHNnzoaAoxiJdodoJdfiJisnvHfqdffHonsDioAvofan
6、
widgEditor[
支持XHTML]
簡介：
widgEditor?is?an?easily?installed,?easily?customisable?WYSIWYG?editor?for?simple?content.?It?replaces?existing?textareas?with?an?improved?editing?pane?using?JavaScript,?therefore?if?you?don't?have?JavaScript?(or?your?browser?doesn't?support?HTML?editing)?it?degrades?gracefully.?Try?it?out?by?typing?below,?and?submit?to?see?the?processed?output.?
使用方法/接口：
在線演示：
http://www.themaninblue.com/experiment/widgEditor/MailMagic下載：widgEditor?
mailmagic://xxvvvsHAzAzJdAffaqNqAdxfNqvxqJsndsHNzDDJqadAAfqqzHaxnNsfdqDaxzfnNdnddzivsfnaNoixzqziDAvsiqqfqiqvAdzxfzDnvqNiNnadivAzdvqxzvoDfdJfNnxaqovnAfJfDnxiDvNDvqaAvqNizqzodfAfqHvNofzxzsivaxaqioaavHvDNqqDJJnzvqsoHxozoqniaJfavaisoHqaDJJffJdzHiHqfisisssdoDaoiAaJHiNDsddi
這篇文章對主流的在線WYSIWYG編輯器做了個詳細的比較：
http://www.geniisoft.com/showcase.nsf/WebEditors
?????
物化視圖是包括一個查詢結果的數據庫對像，它是遠程數據的的本地副本，或者用來生成基于數據表求和的匯總表。物化視圖存儲基于遠程表的數據，也可以稱為快照。
??????
物化視圖可以查詢表，視圖和其它的物化視圖。
??????
通常情況下，物化視圖被稱為主表（在復制期間）或明細表（在數據倉庫中）。
??????
對于復制，物化視圖允許你在本地維護遠程數據的副本
,
這些副本是只讀的。如果你想修改本地副本，必須用高級復制的功能。當你想從一個表或視圖中抽取數據時，你可以用從物化視圖中抽取。
??????
對于數據倉庫，創建的物化視圖通常情況下是聚合視圖，單一表聚合視圖和連接視圖。
本文我們將會看到怎樣創建物化視圖并且討論它的刷新選項。
??????
在復制環境下，創建的物化視圖通常情況下主鍵，
rowid,
和子查詢視圖。
1.
主鍵物化視圖：
??????
??????
下面的語法在遠程數據庫表
emp
上創建主鍵物化視圖
SQL> CREATE MATERIALIZED VIEW mv_emp_pk
REFRESH FAST START WITH SYSDATE
??? NEXT? SYSDATE + 1/48
WITH PRIMARY KEY
??? AS SELECT * FROM emp@remote_db;
Materialized view created.
???
注意：當用
FAST
選項創建物化視圖，必須創建基于主表的視圖日志
,
如下
:
??????SQL> CREATE MATERIALIZED VIEW LOG ON emp;Materialized view log created.
2.
Rowid
物化視圖
??????
??????
下面的語法在遠程數據庫表
emp
上創建
Rowid
物化視圖
SQL> CREATE MATERIALIZED VIEW mv_emp_rowid
REFRESH WITH ROWID
???? AS SELECT * FROM emp@remote_db;
Materialized view log created.
3.
子查詢物化視圖
??????
??????
下面的語法在遠程數據庫表
emp
上創建基于
emp
和
dept
表的子查詢物化視圖
SQL> CREATE MATERIALIZED VIEW? mv_empdept
AS SELECT * FROM emp@remote_db e
???? WHERE EXISTS
?? (SELECT * FROM dept@remote_db d
??????? WHERE e.dept_no = d.dept_no)
Materialized view log created.
??????
REFRESH
子句
[refresh [fast|complete|force]
???????? [on demand | commit]
???????? [start with date] [next date]
???????? [with {primary key|rowid}]]
??????
Refresh
選項說明
:
a.
?????
oracle
用刷新方法在物化視圖中刷新數據
.
b.
?????
是基于主鍵還是基于
rowid
的物化視圖
c.
??????
物化視圖的刷新時間和間隔刷新時間
?
Refresh
方法
-FAST
子句
??????
增量刷新用物化視圖日志（參照上面所述）來發送主表已經修改的數據行到物化視圖中
.
如果指定
REFRESH FAST
子句，那么應該對主表創建物化視圖日志
SQL> CREATE MATERIALIZED VIEW LOG ON emp;
Materialized view log created.
??????
對于增量刷新選項，如果在子查詢中存在分析函數，則物化視圖不起作用。
?
Refresh
方法
-COMPLETE
子句
??????
完全刷新重新生成整個視圖，如果請求完全刷新，
oracle
會完成
??????
完全刷新即使增量刷新可用。
?
Refresh Method – FORCE
子句
??????
當指定
FORCE
子句，如果增量刷新可用
Oracle
將完成增量刷新，否則將完成完全刷新
,
如果不指定刷新方法
(FAST, COMPLETE, or FORCE),Force
選項是默認選項
?
主鍵和
ROWD
子句
?????? WITH PRIMARY KEY
選項生成主鍵物化視圖
,
也就是說物化視圖是基于主表的主鍵，而不是
ROWID(
對應于
ROWID
子句
). PRIMARY KEY
是默認選項
,
為了生成
PRIMARY KEY
子句，應該在主表上定義主鍵，否則應該用基于
ROWID
的物化視圖
.
??????
主鍵物化視圖允許識別物化視圖主表而不影響物化視圖增量刷新的可用性。
??????
Rowid
物化視圖只有一個單一的主表，不能包括下面任何一項
:
n
????????
Distinct
或者聚合函數
.
n
????????
Group by
，子查詢，連接和
SET
操作
?
刷新時間
??????
??????
START WITH
子句通知數據庫完成從主表到本地表第一次復制的時間
,
應該及時估計下一次運行的時間點
, NEXT
子句說明了刷新的間隔時間
.
SQL> CREATE MATERIALIZED VIEW mv_emp_pk
??????????? REFRESH FAST
??????????? START WITH SYSDATE
??????????? NEXT? SYSDATE + 2
??????????? WITH PRIMARY KEY
????????????? AS SELECT * FROM emp@remote_db;
???????????????? Materialized view created.
在上面的例子中，物化視圖數據的第一個副本在創建時生成，以后每兩天刷新一次
.
?
總結
物化視圖提供了可伸縮的基于主鍵或
ROWID
的視圖
,
指定了刷新方法和自動刷新的時間。