想來學習Java也有兩個年頭了，永遠不敢說多么精通，但也想談談自己的感受，寫給軟件學院的同仁們，幫助大家在技術的道路上少一點彎路。說得偉大一點是希望大家為軟件學院爭氣，其實最主要的還是大家自身的進步提升??

1． 關于動態加載機制??
學習Java比C++更容易理解OOP的思想，畢竟C++還混合了不少面向過程的成分。很多人都能背出來Java語言的特點，所謂的動態加載機制等等。當然概念往往是先記住而后消化的，可有多少人真正去體會過動態加載的機制，試圖去尋找過其中的細節呢? 提供大家一個方法：
在命令行窗口運行Java程序的時候，加上這個很有用的參數：

java -verbose *.class

這樣會清晰的打印出被加載的類文件，大部分是jdk自身運行需要的，最后幾行會明顯的看到自己用到的那幾個類文件被加載進來的順序。即使你聲明了一個類對象，不實例化也不會加載，說明只有真正用到那個類的實例即對象的時候，才會執行加載。這樣是不是大家稍微能明白一點動態加載了呢？^_^

2． 關于尋找class文件原理??
建議大家在入門的時候在命令行窗口編譯和運行，不要借助JCreator或者Eclipse等IDE去幫助做那些事情。嘗試自己這樣做：
javac -classpath yourpath *.java
java -classpath yourpath *.class
也許很多人都能看懂，設置classpath的目的就是告訴編譯器去哪里尋找你的class文件. 不過至少筆者今日才弄懂JVM去查詢類的原理，編譯器加載類要依靠classloader， 而classloader有3個級別，從高到低分別是BootClassLoader(名字可能不準確) , ExtClassLoader, AppClassLoader.

這3個加載器分別對應著編譯器去尋找類文件的優先級別和不同的路徑：BootClassLoader對應jre/classes路徑，是編譯器最優先尋找class的地方
ExtClassLoader對應jre/lib/ext路徑，是編譯器次優先尋找class的地方
AppClassLoader對應當前路徑，所以也是編譯器默認找class的地方

其實大家可以自己寫個程序簡單的測試，對任何class，例如A,
調用new A().getClass().getClassLoader().toString() 打印出來就可以看到，把class文件放在不同的路徑下再次執行，就會看到區別。特別注意的是如果打印出來是null就表示到了最高級 BootClassLoader, 因為它是C++編寫的，不存在Java對應的類加載器的名字。

尋找的順序是一種向上迂回的思想，即如果本級別找不到，就只能去本級別之上的找，不會向下尋找。不過似乎從Jdk1.4到Jdk1.6這一特點又有改變，沒有找到詳細資料。所以就不舉例子了。告訴大家設計這種體系的是Sun公司曾經的技術核心宮力先生，一個純種華人哦！^_^

這樣希望大家不至于迷惑為什么總報錯找不到類文件，不管是自己寫的還是導入的第三方的jar文件（J2ee中經常需要導入的）。

3． 關于jdk和jre??
大家肯定在安裝JDK的時候會有選擇是否安裝單獨的jre，一般都會一起安裝，我也建議大家這樣做。因為這樣更能幫助大家弄清楚它們的區別：

Jre 是java runtime environment, 是java程序的運行環境。既然是運行，當然要包含jvm，也就是大家熟悉的虛擬機啦， 還有所有java類庫的class文件，都在lib目錄下打包成了jar。大家可以自己驗證。至于在windows上的虛擬機是哪個文件呢？ 學過MFC的都知道什么是dll文件吧，那么大家看看jre/bin/client里面是不是有一個jvm.dll呢？那就是虛擬機。

Jdk 是java development kit，是java的開發工具包，里面包含了各種類庫和工具。當然也包括了另外一個Jre. 那么為什么要包括另外一個Jre呢？而且jdk/jre/bin同時有client和server兩個文件夾下都包含一個jvm.dll。 說明是有兩個虛擬機的。這一點不知道大家是否注意到了呢？

相信大家都知道jdk的bin下有各種java程序需要用到的命令，與jre的bin目錄最明顯的區別就是jdk下才有javac，這一點很好理解，因為 jre只是一個運行環境而已。與開發無關，正因為如此，具備開發功能的jdk自己的jre下才會同時有client性質的jvm和server性質的 jvm， 而僅僅作為運行環境的jre下只需要client性質的jvm.dll就夠了。

記得在環境變量path中設置jdk/bin路徑麼？這應該是大家學習Java的第一步吧， 老師會告訴大家不設置的話javac和java是用不了的。確實jdk/bin目錄下包含了所有的命令。可是有沒有人想過我們用的java命令并不是 jdk/bin目錄下的而是jre/bin目錄下的呢？不信可以做一個實驗，大家可以把jdk/bin目錄下的java.exe剪切到別的地方再運行 java程序，發現了什么？一切OK！

那么有人會問了？我明明沒有設置jre/bin目錄到環境變量中啊？

試想一下如果java為了提供給大多數人使用，他們是不需要jdk做開發的，只需要jre能讓java程序跑起來就可以了，那么每個客戶還需要手動去設置環境變量多麻煩啊？所以安裝jre的時候安裝程序自動幫你把jre的java.exe添加到了系統變量中，驗證的方法很簡單，大家看到了系統環境變量的 path最前面有“%SystemRoot%\system32;%SystemRoot%;”這樣的配置，那么再去Windows/system32下面去看看吧，發現了什么？有一個java.exe。

如果強行能夠把jdk/bin挪到system32變量前面，當然也可以迫使使用jdk/jre里面的java，不過除非有必要，我不建議大家這么做。使用單獨的jre跑java程序也算是客戶環境下的一種測試。

這下大家應該更清楚jdk和jre內部的一些聯系和區別了吧？

PS: 其實還有滿多感想可以總結的，一次寫多了怕大家扔磚頭砸死我，怪我太羅唆。大家應該更加踏實更加務實的去做一些研究并互相分享心得，大方向和太前沿的技術討論是必要的但最好不要太多，畢竟自己基礎都還沒打好，什么都講最新版本其實是進步的一大障礙！


Java 學習雜談（二）?

鑒于上回寫的一點感想大家不嫌棄，都鼓勵小弟繼續寫下去，好不容易等到國慶黃金周，實習總算有一個休息的階段，于是這就開始寫第二篇了。希望這次寫的仍然對志同道合的朋友們有所幫助。上回講了Java動態加載機制、classLoader原理和關于jdk和jre三個問題。這次延續著講一些具體的類庫??

1． 關于集合框架類
相信學過Java的各位對這個名詞并不陌生，對 java.util.*這個package肯定也不陌生。不知道大家查詢API的時候怎么去審視或者分析其中的一個package，每個包最重要的兩個部分就是interfaces和classes，接口代表了它能做什么，實現類則代表了它如何去做。關注實現類之前，我們應該先理解清楚它的來源接口，不管在j2se還是j2ee中，都應該是這樣。那么我們先看這三個接口：List、Set、Map。
也許有些人不太熟悉這三個名字，但相信大部分人都熟悉ArrayList，LinkedList，TreeSet，HashSet，HashMap， Hashtable等實現類的名字。它們的區別也是滿容易理解的，List放可以重復的對象集合，Set放不可重復的對象組合，而Map則放 <Key,Value > 這樣的名值對， Key不可重復，Value可以。這里有幾個容易混淆的問題：

到底Vector和ArrayList，Hashtable和HashMap有什么區別？
很多面試官喜歡問這個問題，其實更專業一點應該這樣問：新集合框架和舊集合框架有哪些區別？新集合框架大家可以在這些包中找since jdk1.2的，之前的如vector和Hashtable都是舊的集合框架包括的類。那么區別是？
a. 新集合框架的命名更加科學合理。例如List下的ArrayList和LinkedList
b. 新集合框架下全部都是非線程安全的。建議去jdk里面包含的源代碼里面自己去親自看看vector和ArrayList的區別吧。當然如果是jdk5.0之后的會比較難看一點，因為又加入了泛型的語法，類似c++的template語法。

那么大家是否想過為什么要從舊集合框架默認全部加鎖防止多線程訪問更新到新集合框架全部取消鎖，默認方式支持多線程？(當然需要的時候可以使用collections的靜態方法加鎖達到線程安全)
筆者的觀點是任何技術的發展都未必是遵循它們的初衷的，很多重大改變是受到客觀環境的影響的。大家知道Java的初衷是為什么而開發的麼？是為嵌入式程序開發的。記得上一篇講到classLoader機制麼？那正是為了節約嵌入式開發環境下內存而設計的。而走到今天，Java成了人們心中為互聯網誕生的語言。互聯網意味著什么？多線程是必然的趨勢。客觀環境在變，Java技術也隨著飛速發展，導致越來越脫離它的初衷。據說Sun公司其實主打的是J2se，結果又是由于客觀環境影響，J2se幾乎遺忘，留在大家談論焦點的一直是j2ee。

技術的細節這里就不多說了，只有用了才能真正理解。解釋這些正是為了幫助大家理解正在學的和將要學的任何技術。之后講j2ee的時候還會再討論。
多扯句題外話：幾十年前的IT巨人是IBM，Mainframe市場無人可比。微軟如何打敗IBM？正是由于硬件飛速發展，對個人PC的需求這個客觀環境，讓微軟通過OS稱為了第二個巨人。下一個打敗微軟的呢？Google。如何做到的？如果微軟并不和IBM爭大型機，Google借著互聯網飛速發展這個客觀環境作為決定性因素，避開跟微軟爭OS，而是走搜索引擎這條路，稱為第3個巨人。那么第4個巨人是誰呢？很多專家預言將在亞洲或者中國出現， Whatever，客觀環境變化趨勢才是決定大方向的關鍵。當然筆者也希望會出現在中國，^_^~~

2． 關于Java設計模式
身邊的很多在看GOF的23種設計模式，似乎學習它無論在學校還是在職場，都成了一種流行風氣。我不想列舉解釋這23種Design Pattern， 我寫這些的初衷一直都是談自己的經歷和看法，希望能幫助大家理解。
首先我覺得設計模式只是對一類問題的一種通用解決辦法，只要是面向對象的編程預言都可以用得上這23種。理解它們最好的方法就是親自去寫每一種，哪怕是一個簡單的應用就足夠了。如果代碼實現也記不住的話，記憶它們對應的UML圖會是一個比較好的辦法，當然前提是必須了解UML。
同時最好能利用Java自身的類庫幫助記憶，例如比較常用的觀察者模式，在java.util.*有現成的Observer接口和Observable這個實現類，看看源代碼相信就足夠理解觀察者模式了。再比如裝飾器模式，大家只要寫幾個關于java.io.*的程序就可以完全理解什么是裝飾器模式了。有很多人覺得剛入門的時候不該接觸設計模式，比如圖靈設計叢書系列很出名的那本《Java設計模式》，作者: Steven John Metsker，大部分例子老實說令現在的我也很迷惑。但我仍然不同意入門跟學習設計模式有任何沖突，只是我們需要知道每種模式的概念的和典型的應用，這樣我們在第一次編寫 FileOutputStream、BufferedReader、PrintWriter的時候就能感覺到原來設計模式離我們如此之近，而且并不是多么神秘的東西。

另外，在學習某些模式的同時，反而更能幫助我們理解java類庫的某些特點。例如當你編寫原型(Prototype)模式的時候，你必須了解的是 java.lang.Cloneable這個接口和所有類的基類Object的clone()這個方法。即深copy和淺copy的區別：
Object.clone()默認實現的是淺copy，也就是復制一份對象拷貝，但如果對象包含其他對象的引用，不會復制引用，所以原對象和拷貝共用那個引用的對象。
深copy當然就是包括對象的引用都一起復制啦。這樣原對象和拷貝對象，都分別擁有一份引用對象。如果要實現深copy就必須首先實現 java.lang.Cloneable接口，然后重寫clone()方法。因為在Object中的clone()方法是protected簽名的，而 Cloneable接口的作用就是把protected放大到public，這樣clone()才能被重寫。

那么又有個問題了？如果引用的對象又引用了其他對象呢？這樣一直判斷并復制下去，是不是顯得很麻煩？曾經有位前輩告訴我的方法是重寫clone方法的時候直接把原對象序列化到磁盤上再反序列化回來，這樣不用判斷就可以得到一個深copy的結果。如果大家不了解序列化的作法建議看一看 ObjectOutputStream和ObjectInputStream

歸根結底，模式只是思想上的東西，把它當成前人總結的經驗其實一點都不為過。鼓勵大家動手自己去寫，例如代理模式，可以簡單的寫一個Child類， Adult類。Child要買任何東西由Adult來代理實現。簡單來說就是Adult里的buy()內部實際調用的是Child的buy()，可是暴露在main函數的卻是Adult.buy()。這樣一個簡單的程序就足夠理解代理模式的基本含義了。

Java 雜談（三）?

這已經筆者寫的第三篇Java雜記了，慶幸前兩篇一直得到論壇朋友們的支持鼓勵，還望大家繼續指正不足之處。筆者也一直渴望通過這樣方式清醒的自審，來尋找自己技術上的不足之處，希望和共同愛好Java的同仁們一起提高。
前兩次分別講述了關于jvm、jdk、jre、collection、classLoader和一些Design Pattern的自我理解。這次仍然不準備開始過渡到j2ee中，因為覺得還有一些瑣碎的j2se的問題沒有總結完畢。

1． 關于Object類理解
大家都知道Object是所有Java類的基類， 意味著所有的Java類都會繼承了Object的11個方法。建議大家去看看Object的 11個成員函數的源代碼，就會知道默認的實現方式。比如equals方法，默認實現就是用"=="來比較，即直接比較內存地址，返回true 或者 false。而toString()方法，返回的串組成方式是??
"getClass().getName() + "@" + Integer.toHexString(hashCode())"
其實不用我過多的解釋，大家都能看懂這個串的組成。接下來再看看hashCode()：
public native int hashCode()；

由于是native方法，跟OS的處理方式相關，源代碼里僅僅有一個聲明罷了。我們有興趣的話完全可以去深究它的hashCode到底是由OS怎么樣產生的呢？但筆者建議最重要的還是先記住使用它的幾條原則吧！首先如果equals()方法相同的對象具有相通的hashCode，但equals ()對象不相通的時候并不保證hashCode()方法返回不同的整數。而且下一次運行同一個程序，同一個對象未必還是當初的那個hashCode() 哦。
其余的方法呢？nofigy()、notifyAll()、clone()、wait()都是native方法的，說明依賴于操作系統的實現。最后一個有趣的方法是finalize()，類似C++的析構函數，簽名是protected，證明只有繼承擴展了才能使用，方法體是空的，默示什么也不做。它的作用據筆者的了解僅僅是通知JVM此對象不再使用，隨時可以被銷毀，而實際的銷毀權還是在于虛擬機手上。那么它真的什么也不做麼？未必，實際上如果是線程對象它會導致在一定范圍內該線程的優先級別提高，導致更快的被銷毀來節約內存提高性能。其實從常理來說，我們也可以大概這樣猜測出jvm做法的目的。

2． 關于重載hashCode()與Collection框架的關系
筆者曾經聽一位搞Java培訓多年的前輩說在他看來hashCode方法沒有任何意義，僅僅是為了配合證明具有同樣的hashCode會導致equals 方法相等而存在的。連有的前輩都犯這樣的錯誤，其實說明它還是滿容易被忽略的。那么hashCode()方法到底做什么用？

學過數據結構的課程大家都會知道有一種結構叫hash table，目的是通過給每個對象分配一個唯一的索引來提高查詢的效率。那么Java也不會肆意扭曲改變這個概念，所以hashCode唯一的作用就是為支持數據結構中的哈希表結構而存在的，換句話說，也就是只有用到集合框架的 Hashtable、HashMap、HashSet的時候，才需要重載hashCode()方法，
這樣才能使得我們能人為的去控制在哈希結構中索引是否相等。筆者舉一個例子：
曾經為了寫一個求解類程序，需要隨機列出1,2,3,4組成的不同排列組合，所以筆者寫了一個數組類用int[]來存組合結果，然后把隨機產生的組合加入一個HashSet中，就是想利用HashSet不包括重復元素的特點。可是HashSet怎么判斷是不是重復的元素呢？當然是通過 hashCode()返回的結果是否相等來判斷啦，可做一下這個實驗：
int[] A = {1,2,3,4};
int[] B = {1,2,3,4};
System.out.println(A.hashCode());
System.out.println(B.hashCode());

這明明是同一種組合，卻是不同的hashCode，加入Set的時候會被當成不同的對象。這個時候我們就需要自己來重寫hashCode()方法了，如何寫呢？其實也是基于原始的hashCode()，畢竟那是操作系統的實現， 找到相通對象唯一的標識，實現方式很多，筆者的實現方式是：
首先重寫了toString()方法:
return A[0]“+” A[1]“+” A[2]“+” A[3]; //顯示上比較直觀
然后利用toString()來計算hashCode()：
return this.toString().hashCode()；
這樣上述A和B返回的就都是”1234”，在測試toString().hashCode()，由于String在內存中的副本是一樣的，”1234”.hashCode()返回的一定是相同的結果。

說到這，相信大家能理解得比我更好，今后千萬不要再誤解hashCode()方法的作用。

3． 關于Class類的成員函數與Java反射機制
很早剛接觸Java就聽很多老師說過Java的動態運行時機制、反射機制等。確實它們都是Java的顯著特點，運行時加載筆者在第一篇介紹過了，現在想講講反射機制。在Java中，主要是通過java.lang包中的Class類和Method類來實現內存反射機制的。
熟悉C++的人一定知道下面這樣在C++中是做不到的： 運行時以字符串參數傳遞一個類名，就可以得到這個類的所有信息，包括它所有的方法，和方法的詳細信息。還可以實例化一個對象，并通過查到的方法名來調用該對象的任何方法。這是因為Java的類在內存中除了C++中也有的靜態動態數據區之外，還包括一份對類自身的描述，也正是通過這描述中的信息，才能幫助我們才運行時讀取里面的內容，得到需要加載目標類的所有信息，從而實現反射機制。大家有沒有想過當我們需要得到一個JavaBean的實例的時候，怎么知道它有哪些屬性呢？再明顯簡單不過的例子就是自己寫一個JavaBean的解析器：

a. 通過Class.forName(“Bean的類名”)得到Class對象，例如叫ABeanClass
b. 通過ABeanClass的getMethods()方法，得到Method[]對象
c. 按照規范所有get方法名后的單詞就代表著該Bean的一個屬性
d. 當已經知道一個方法名，可以調用newInstance()得到一個實例，然后通過invoke()方法將方法的名字和方法需要用的參數傳遞進去，就可以動態調用此方法。

當然還有更復雜的應用，這里就不贅述，大家可以參考Class類和Method類的方法。

4． 坦言Synchronize的本質
Synchronize大家都知道是同步、加鎖的意思，其實它的本質遠沒有大家想得那么復雜。聲明Synchronize的方法被調用的時候，鎖其實是加載對象上，當然如果是靜態類則是加在類上的鎖，調用結束鎖被解除。它的實現原理很簡單，僅僅是不讓第二把鎖再次被加在同一個對象或類上，僅此而已。一個簡單的例子足以說明問題：
class A{
synchronized void f(){}
void g(){}
}

當A的一個對象a被第一個線程調用其f()方法的時候，第二個線程不能調用a的synchronized方法例如f()，因為那是在試圖在對象上加第二把鎖。但調用g()卻是可以的，因為并沒有在同一對象上加兩把鎖的行為產生。
這樣大家能理解了麼？明白它的原理能更好的幫助大家設計同步機制，不要濫用加鎖。

PS：下篇筆者計劃開始對J2ee接觸到的各個方面來進行總結，談談自己的經驗和想法。希望大家還能一如既往的支持筆者寫下去，指正不足之處。

Java雜談（四）

不知不覺已經寫到第四篇了，論壇里面不斷的有朋友鼓勵我寫下去。堅持自己的作風，把一切迷惑不容易理清楚的知識講出來，講到大家都能聽懂，那么自己就真的懂了。最近在公司實習的時候Trainer跟我講了很多經典事跡，對還未畢業的我來說是筆不小的財富，我自己的信念是：人在逆境中成長的速度要遠遠快過順境中，這樣來看一切都能欣然接受了。
好了，閑話不說了，第三篇講的是反射機制集合框架之類的，這次打算講講自己對反序列化和多線程的理解。希望能對大家學習Java起到幫助??

1．關于序列化和反序列化
應該大家都大概知道Java中序列化和反序列化的意思，序列化就是把一個Java對象轉換成二進制進行磁盤上傳輸或者網絡流的傳輸，反序列化的意思就是把這個接受到的二進制流重新組裝成原來的對象逆過程。它們在Java中分別是通過ObjectInputStream和 ObjectInputStream這兩個類來實現的（以下分別用ois和oos來簡稱）。

oos的writeObject()方法用來執行序列化的過程，ois的readObject()用來執行反序列化的過程，在傳輸二進制流之前，需要講這兩個高層流對象連接到同一個Channel上，這個Channel可以是磁盤文件，也可以是socket底層流。所以無論用哪種方式，底層流對象都是以構造函數參數的形式傳遞進oos和ois這兩個高層流，連接完畢了才可以進行二進制數據傳輸的。例子：
可以是文件流通道
file = new File(“C:/data.dat”);
oos = new ObjectOutputStream(new FileOutputStream(file));
ois = new ObjectInputStream(new FileInputStream(file));

或者網絡流通道
oos = new ObjectOutputStream(socket.getOutputStream());
ois = new ObjectInputStream(socket.getInputStream());

不知道大家是否注意到oos總是在ois之前定義，這里不希望大家誤解這個順序是固定的么？回答是否定的，那么有順序要求么？回答是肯定的。原則是什么呢？
原則是互相對接的輸入/輸出流之間必須是output流先初始化然后再input流初始化，否則就會拋異常。大家肯定會問為什么？只要稍微看一看這兩個類的源代碼文件就大概知道了，output流的任務很簡單，只要把對象轉換成二進制往通道中寫就可以了，但input流需要做很多準備工作來接受并最終重組這個Object，所以ObjectInputStream的構造函數中就需要用到output初始化發送過來的header信息，這個方法叫做 readStreamHeader()，它將會去讀兩個Short值用于決定用多大的緩存來存放通道發送過來的二進制流，這個緩存的size因jre的版本不同是不一樣的。所以output如果不先初始化，input的構造函數首先就無法正確運行。

對于上面兩個例子，第一個順序是嚴格的，第二個因為oos和ois連接的已經不是對方了，而是socket另外一端的流，需要嚴格按照另外一方對接的output流先于對接的input流打開才能順利運行。

這個writeObject和readObject本身就是線程安全的，傳輸過程中是不允許被并發訪問的。所以對象能一個一個接連不斷的傳過來，有很多人在運行的時候會碰到EOFException, 然后百思不得其解，去各種論壇問解決方案。其實筆者這里想說，這個異常不是必須聲明的，也就是說它雖然是異常，但其實是正常運行結束的標志。EOF表示讀到了文件尾，發送結束自然連接也就斷開了。如果這影響到了你程序的正確性的話，請各位靜下心來看看自己程序的業務邏輯，而不要把注意力狹隘的聚集在發送和接受的方法上。因為筆者也被這樣的bug困擾了1整天，被很多論壇的帖子誤解了很多次最后得出的教訓。如果在while循環中去readObject，本質上是沒有問題的，有對象數據來就會讀，沒有就自動阻塞。那么拋出EOFException一定是因為連接斷了還在繼續read，什么原因導致連接斷了呢？一定是業務邏輯哪里存在錯誤，比如NullPoint、 ClassCaseException、ArrayOutofBound，即使程序較大也沒關系，最多只要單步調適一次就能很快發現bug并且解決它。

難怪一位程序大師說過：解決問題90％靠經驗，5％靠技術，剩下5％靠運氣！真是金玉良言，筆者大概查閱過不下30篇討論在while循環中使用 readObject拋出EOFExceptionde 的帖子，大家都盲目的去關注解釋這個名詞、反序列化的行為或反對這樣寫而沒有一個人認為EOF是正確的行為，它其實很老實的在做它的事情。為什么大家都忽略了真正出錯誤的地方呢？兩個字，經驗！

2．關于Java的多線程編程
關于Java的線程，初學或者接觸不深的大概也能知道一些基本概念，同時又會很迷惑線程到底是怎么回事？如果有人認為自己已經懂了不妨來回答下面的問題：
a. A對象實現Runnable接口，A.start()運行后所謂的線程對象是誰？是A么？
b. 線程的wait()、notify()方法到底是做什么時候用的，什么時候用？
c. 為什么線程的suspend方法會被標注過時，不推薦再使用，線程還能掛起么？
d. 為了同步我們會對線程方法聲明Synchronized來加鎖在對象上，那么如果父類的f()方法加了Synchronized，子類重寫f()方法必須也加Synchronized么？如果子類的f()方法重寫時聲明Synchronized并調用super.f()，那么子類對象上到底有幾把鎖呢？會因為競爭產生死鎖么？

呵呵，各位能回答上來幾道呢？如果這些都能答上來，說明對線程的概念還是滿清晰的，雖說還遠遠不能算精通。筆者這里一一做回答，礙于篇幅的原因，筆者盡量說得簡介一點，如果大家有疑惑的歡迎一起討論。

首先第一點，線程跟對象完全是兩回事，雖然我們也常說線程對象。但當你用run()和start()來啟動一個線程之后，線程其實跟這個繼承了 Thread或實現了Runnable的對象已經沒有關系了，對象只能算內存中可用資源而對象的方法只能算內存正文區可以執行的代碼段而已。既然是資源和代碼段，另外一個線程當然也可以去訪問，main函數執行就至少會啟動兩個線程，一個我們稱之為主線程，還一個是垃圾收集器的線程，主線程結束就意味著程序結束，可垃圾收集器線程很可能正在工作。

第二點，wait()和sleep()類似，都是讓線程處于阻塞狀態暫停一段時間，不同之處在于wait會釋放當前線程占有的所有的鎖，而 sleep不會。我們知道獲得鎖的唯一方法是進入了Synchronized保護代碼段，所以大家會發現只有Synchronized方法中才會出現 wait，直接寫會給警告沒有獲得當前對象的鎖。所以notify跟wait配合使用，notify會重新把鎖還給阻塞的線程重而使其繼續執行，當有多個對象wait了，notify不能確定喚醒哪一個，必經鎖只有一把，所以一般用notifyAll()來讓它們自己根據優先級等競爭那唯一的一把鎖，競爭到的線程執行，其他線程只要繼續wait。

從前Java允許在一個線程之外把線程掛起，即調用suspend方法，這樣的操作是極不安全的。根據面向對象的思想每個對象必須對自己的行為負責，而對自己的權力進行封裝。如果任何外步對象都能使線程被掛起而阻塞的話，程序往往會出現混亂導致崩潰，所以這樣的方法自然是被斃掉了啦。

最后一個問題比較有意思，首先回答的是子類重寫f()方法可以加Synchronized也可以不加，如果加了而且還內部調用了super.f ()的話理論上是應該對同一對象加兩把鎖的，因為每次調用Synchronized方法都要加一把，調用子類的f首先就加了一把，進入方法內部調用父類的 f又要加一把，加兩把不是互斥的么？那么調父類f加鎖不就必須永遠等待已經加的鎖釋放而造成死鎖么？實際上是不會的，這個機制叫重進入，當父類的f方法試圖在本對象上再加一把鎖的時候，因為當前線程擁有這個對象的鎖，也可以理解為開啟它的鑰匙，所以同一個線程在同一對象上還沒釋放之前加第二次鎖是不會出問題的，這個鎖其實根本就沒有加，它有了鑰匙，不管加幾把還是可以進入鎖保護的代碼段，暢通無阻，所以叫重進入，我們可以簡單認為第二把鎖沒有加上去。

總而言之，Synchronized的本質是不讓其他線程在同一對象上再加一把鎖。?

Java雜談（五）

本來預計J2se只講了第四篇就收尾了，可是版主厚愛把帖子置頂長期讓大家瀏覽讓小弟倍感責任重大，務必追求最到更好，所以關于J2se一些沒有提到的部分，決定再寫幾篇把常用的部分經驗全部寫出來供大家討論切磋。這一篇準備講一講Xml解析包和Java Swing，然后下一篇再講java.security包關于Java沙箱安全機制和RMI機制，再進入J2ee的部分，暫時就做這樣的計劃了。如果由于實習繁忙更新稍微慢了一些，希望各位見諒！

1． Java關于XML的解析
相信大家對XML都不陌生，含義是可擴展標記語言。本身它也就是一個數據的載體以樹狀表現形式出現。后來慢慢的數據變成了信息，區別是信息可以包括可變的狀態從而針對程序硬編碼的做法變革為針對統一接口硬編碼而可變狀態作為信息進入了XML中存儲。這樣改變狀態實現擴展的唯一工作是在XML中添加一段文本信息就可以了，代碼不需要改動也不需要重新編譯。這個靈活性是XML誕生時候誰也沒想到的。

當然，如果接口要能提取XML中配置的信息就需要程序能解析規范的XML文件，Java中當然要提高包對這個行為進行有利支持。筆者打算講到的兩個包是 org.w3c.dom和javax.xml.parsers和。（大家可以瀏覽一下這些包中間的接口和類定義）

Javax.xml.parsers包很簡單，沒有接口，兩個工廠配兩個解析器。顯然解析XML是有兩種方式的：DOM解析和SAX解析。本質上并沒有誰好誰不好，只是實現的思想不一樣罷了。給一個XML文件的例子：
<?xml version=”1.0” encoding=”UTF-8” >
<root >
<child name=”Kitty” >
A Cat
</child >
</root >

所謂DOM解析的思路是把整個樹狀圖存入內存中，需要那個節點只需要在樹上搜索就可以讀到節點的屬性，內容等，這樣的好處是所有節點皆在內存可以反復搜索重復使用，缺點是需要消耗相應的內存空間。

自然SAX解析的思路就是為了克服DOM的缺點，以事件觸發為基本思路，順序的搜索下來，碰到了Element之前觸發什么事件，碰到之后做什么動作。由于需要自己來寫觸發事件的處理方案，所以需要借助另外一個自定義的Handler，處于org.xml.sax.helpers包中。它的優點當然是不用整個包都讀入內存，缺點也是只能順序搜索，走完一遍就得重來。

大家很容易就能猜到，接觸到的J2ee框架用的是哪一種，顯然是DOM。因為類似Struts，Hibernate框架配置文件畢竟是很小的一部分配置信息，而且需要頻繁搜索來讀取，當然會采用DOM方式（其實SAX內部也是用DOM采用的結構來存儲節點信息的）。現在無論用什么框架，還真難發現使用 SAX來解析XML的技術了，如果哪位仁兄知道，請讓筆者也學習學習。

既然解析方式有了，那么就需要有解析的存儲位置。不知道大家是否發現org.w3c.dom這個包是沒有實現類全部都是接口的。這里筆者想說一下Java 如何對XML解析是Jdk應該考慮的事，是它的責任。而w3c組織是維護定義XML標準的組織，所以一個XML結構是怎么樣的由w3c說了算，它不關心 Java如何去實現，于是乎規定了所有XML存儲的結構應該遵循的規則，這就是org.w3c.dom里全部的接口目的所在。在筆者看來，簡單理解接口的概念就是實現者必須遵守的原則。

整個XML對應的結構叫Document、子元素對應的叫做Element、還有節點相關的Node、NodeList、Text、Entity、 CharacterData、CDATASection等接口，它們都可以在XML的語法中間找到相對應的含義。由于這里不是講解XML基本語法，就不多介紹了。如果大家感興趣，筆者也可以專門寫一篇關于XML的語法規則帖與大家分享一下。

2． Java Swing
Swing是一個讓人又愛又恨的東西，可愛之處在于上手很容易，較AWT比起來Swing提供的界面功能更加強大，可恨之處在于編復雜的界面工作量實在是巨大。筆者寫過超過3000行的Swing界面，感覺用戶體驗還不是那么優秀。最近又寫過超過6000行的，由于功能模塊多了，整體效果還只是一般般。體會最深的就一個字：累! 所以大家現在都陸續不怎么用Swing在真正開發的項目上了，太多界面技術可以取代它了。筆者去寫也是迫于無奈組里面大家都沒寫過，我不入地域誰入？

盡管Swing慢慢的在被人忽略，特別是隨著B/S慢慢的在淹沒C/S，筆者倒是很愿意站出來為Swing正身。每一項技術的掌握絕不是為了流行時尚跟風。真正喜歡Java的朋友們還是應該好好體會一下Swing，相信在校的很多學生也很多在學習它。很可能從Jdk 1.1、1.2走過來的很多大學老師可能是最不熟悉它的。
Swing提供了一組輕組件統稱為JComponent，它們與AWT組件的最大區別是JComponent全部都是Container，而 Container的特點是里面可以裝載別的組件。在Swing組件中無論是JButton、JLabel、JPanel、JList等都可以再裝入任何其他組件。好處是程序員可以對Swing組件實現“再開發”，針對特定需求構建自己的按鈕、標簽、畫板、列表之類的特定組件。

有輕自然就有重，那么輕組件和重組件區別是？重組件表現出來的形態因操作系統不同而異，輕組件是Swing自己提供GUI，在跨平臺的時候最大程度的保持一致。
那么在編程的時候要注意一些什么呢？筆者談談自己的幾點經驗：

a. 明確一個概念，只有Frame組件才可以單獨顯示的，也許有人會說JOptionPane里面的靜態方法就實現了單獨窗口出現，但追尋源代碼會發現其實現實出來的Dialog也需要依托一個Frame窗體，如果沒有指定就會默認產生一個然后裝載這個Dialog顯示出來。

b. JFrame是由這么幾部分組成：
最底下一層JRootPane，上面是glassPane (一個JPanel)和layeredPane (一個JLayeredPane)，而layeredPane又由contentPane(一個JPanel)和menuBar構成。我們的組件都是加在 contentPane上，而背景圖片只能加在layeredPane上面。 至于glassPane是一個透明的覆蓋了contentPane的一層，在特定效果中將被利用到來記錄鼠標坐標或掩飾組件。

c. 為了增強用戶體驗，我們會在一些按鈕上添加快捷鍵，但Swing里面通常只能識別鍵盤的Alt鍵，要加入其他的快捷鍵，必須自己實現一個ActionListener。

d. 通過setLayout(null)可以使得所有組件以setBounds()的四個參數來精確定位各自的大小、位置，但不推薦使用，因為好的編程風格不應該在Swing代碼中硬編碼具體數字，所有的數字應該以常數的形式統一存在一個靜態無實例資源類文件中。這個靜態無實例類統一負責Swing界面的風格，包括字體和顏色都應該包括進去。

e. 好的界面設計有一條Golden Rule: 用戶不用任何手冊通過少數嘗試就能學會使用軟件。所以盡量把按鈕以菜單的形式（不管是右鍵菜單還是窗體自帶頂部菜單）呈現給顧客，除非是頻繁點擊的按鈕才有必要直接呈現在界面中。

其實Swing的功能是相當強大的，只是現在應用不廣泛，專門去研究大概是要花不少時間的。筆者在各網站論壇瀏覽關于Swing的技巧文章還是比較可信的，自己所學非常有限，各人體會對Swing各個組件的掌握就是一個實踐積累的過程。筆者只用到過以上這些，所以只能談談部分想法，還望大家見諒！?

Java雜談（六）

這篇是筆者打算寫的J2se部分的最后一篇了，這篇結束之后，再寫J2ee部分，不知道是否還合適寫在這個版塊？大家可以給點意見，謝謝大家對小弟這么鼓勵一路寫完前六篇Java雜談的J2se部分。最后這篇打算談一談Java中的RMI機制和JVM沙箱安全框架。

1． Java中的RMI機制
RMI的全稱是遠程方法調用，相信不少朋友都聽說過，基本的思路可以用一個經典比方來解釋：A計算機想要計算一個兩個數的加法，但A自己做不了，于是叫另外一臺計算機B幫忙，B有計算加法的功能，A調用它就像調用這個功能是自己的一樣方便。這個就叫做遠程方法調用了。

遠程方法調用是EJB實現的支柱，建立分布式應用的核心思想。這個很好理解，再拿上面的計算加法例子，A只知道去call計算機B的方法，自己并沒有B的那些功能，所以A計算機端就無法看到B執行這段功能的過程和代碼，因為看都看不到，所以既沒有機會竊取也沒有機會去改動方法代碼。EJB正式基于這樣的思想來完成它的任務的。當簡單的加法變成復雜的數據庫操作和電子商務交易應用的時候，這樣的安全性和分布式應用的便利性就表現出來優勢了。

好了，回到細節上，要如何實現遠程方法調用呢？我希望大家學習任何技術的時候可以試著依賴自己的下意識判斷，只要你的想法是合理健壯的，那么很可能實際上它就是這么做的，畢竟真理都蘊藏在平凡的生活細節中。這樣只要帶著一些薄弱的Java基礎來思考RMI，其實也可以想出個大概來。

a) 需要有一個服務器角色，它擁有真正的功能代碼方法。例如B，它提供加法服務
b) 如果想遠程使用B的功能，需要知道B的IP地址
c) 如果想遠程使用B的功能，還需要知道B中那個特定服務的名字

我們很自然可以想到這些，雖然不完善，但已經很接近正確的做法了。實際上RMI要得以實現還得意于Java一個很重要的特性，就是Java反射機制。我們需要知道服務的名字，但又必須隱藏實現的代碼，如何去做呢？答案就是：接口！
舉個例子：
public interface Person(){
public void sayHello();
}

Public class PersonImplA implements Person{
public PersonImplA(){}

public void sayHello(){ System.out.println(“Hello!”);}
}

Public class PersonImplB implements Person{
public PersonImplB(){}

public void sayHello(){ System.out.println(“Nice to meet you!”);}
}

客戶端：Person p = Naming.lookup(“PersonService”);
p.sayHello();

就這幾段代碼就包含了幾乎所有的實現技術，大家相信么？客戶端請求一個say hello服務，服務器運行時接到這個請求，利用Java反射機制的Class.newInstance()返回一個對象，但客戶端不知道服務器返回的是 ImplA還是ImplB，它接受用的參數簽名是Person，它知道實現了Person接口的對象一定有sayHello()方法，這就意味著客戶端并不知道服務器真正如何去實現的，但它通過了解Person接口明確了它要用的服務方法名字叫做sayHello()。

如此類推，服務器只需要暴露自己的接口出來供客戶端，所有客戶端就可以自己選擇需要的服務。這就像餐館只要拿出自己的菜單出來讓客戶選擇，就可以在后臺廚房一道道的按需做出來，它怎么做的通常是不讓客戶知道的！（祖傳菜譜吧，^_^）

最后一點是我調用lookup，查找一個叫PersonService名字的對象，服務器只要看到這個名字，在自己的目錄（相當于電話簿）中找到對應的對象名字提供服務就可以了，這個目錄就叫做JNDI (Java命名與目錄接口），相信大家也聽過的。

有興趣的朋友不妨自己做個RMI的應用，很多前輩的博客中有簡單的例子。提示一下利用Jdk的bin目錄中rmi.exe和 rmiregistry.exe兩個命令就可以自己建起一個服務器，提供遠程服務。因為例子很容易找，我就不自己舉例子了！

2． JVM沙箱&框架
RMI羅唆得太多了，實在是盡力想把它說清楚，希望對大家有幫助。最后的最后，給大家簡單講一下JVM框架，我們叫做Java沙箱。Java沙箱的基本組件如下：
a) 類裝載器結構
b) class文件檢驗器
c) 內置于Java虛擬機的安全特性
d) 安全管理器及Java API

其中類裝載器在3個方面對Java沙箱起作用：
a. 它防止惡意代碼去干涉善意的代碼
b. 它守護了被信任的類庫邊界
c. 它將代碼歸入保護域，確定了代碼可以進行哪些操作

虛擬機為不同的類加載器載入的類提供不同的命名空間，命名空間由一系列唯一的名稱組成，每一個被裝載的類將有一個名字，這個命名空間是由Java虛擬機為每一個類裝載器維護的，它們互相之間甚至不可見。

我們常說的包（package）是在Java虛擬機第2版的規范第一次出現，正確定義是由同一個類裝載器裝載的、屬于同一個包、多個類型的集合。類裝載器采用的機制是雙親委派模式。具體的加載器框架我在Java雜談（一）中已經解釋過了，當時說最外層的加載器是AppClassLoader，其實算上網絡層的話AppClassLoader也可以作為parent，還有更外層的加載器URLClassLoader。為了防止惡意攻擊由URL加載進來的類文件我們當然需要分不同的訪問命名空間，并且制定最安全的加載次序，簡單來說就是兩點：

a. 從最內層JVM自帶類加載器開始加載，外層惡意同名類得不到先加載而無法使用
b. 由于嚴格通過包來區分了訪問域，外層惡意的類通過內置代碼也無法獲得權限訪問到內層類，破壞代碼就自然無法生效。

附：關于Java的平臺無關性，有一個例子可以很明顯的說明這個特性：
一般來說，C或C++中的int占位寬度是根據目標平臺的字長來決定的，這就意味著針對不同的平臺編譯同一個C++程序在運行時會有不同的行為。然而對于 Java中的int都是32位的二進制補碼標識的有符號整數，而float都是遵守IEEE 754浮點標準的32位浮點數。

PS: 這個小弟最近也沒時間繼續研究下去了，只是想拋磚引玉的提供給大家一個初步認識JVM的印象。有機會了解一下JVM的內部結構對今后做Java開發是很有好處的。

Java雜談（七）－－接口& 組件、容器

終于又靜下來繼續寫這個主題的續篇，前六篇主要講了一些J2se方面的經驗和感受， 眼下Java應用范圍已經被J2ee占據了相當大的一塊領域，有些人甚至聲稱Java被J2ee所取代了。不知道大家如何來理解所謂的J2ee (Java2 Enterprise Edition)，也就是Java企業級應用？

筆者的觀點是，技術的發展是順應世界變化的趨勢的，從C/S過渡到B/S模式，從客戶端的角度考慮企業級應用或者說電子商務領域不在關心客戶端維護問題，這個任務已經交給了任何一臺PC都會有的瀏覽器去維護；從服務器端的角度考慮，以往C/S中的TCP/IP協議實現載體ServerSocket被Web Server Container所取代，例如大家都很熟悉的Tomcat、JBoss、WebLogic等等。總之一切的轉變都是為了使得Java技術能更好的為人類生產生活所服務。

有人會問，直接去學J2ee跳過J2se行否？筆者是肯定不贊成的，實際上確實有人走這條路，但筆者自身體會是正是由于J2se的基礎很牢固，才會導致在J2ee學習的道路上順風順水，知識點上不會有什么迷惑的地方。舉個簡單的例子吧：

筆者曾經跟大學同學討論下面這兩種寫法的區別：
ArrayList list = new ArrayList(); //筆者不說反對，但至少不贊成
List list = new ArrayList(); //筆者支持
曾經筆者跟同學爭論了幾個小時，他非說第一種寫法更科學，第二種完全沒有必要。我無法完全說服他，但筆者認為良好的習慣和意識是任何時候都應該針對接口編程，以達到解耦合和可擴展性的目的。下面就以接口開始進入J2ee的世界吧：

1. J2ee與接口

每一個版本的J2ee都對應著一個確定版本的JDK，J2ee1.4對應Jdk1.4，現在比較新的是JDK5.0，自然也會有J2EE 5.0。其實筆者一直在用的是J2EE1.4，不過沒什么關系，大家可以下任何一個版本的J2ee api來稍微瀏覽一下。筆者想先聲明一個概念，J2ee也是源自Java，所以底層的操作依然調用到很多J2se的庫，所以才建議大家先牢牢掌握J2se 的主流技術。

J2ee api有一個特點，大家比較熟悉的幾個包java.jms、javax.servlet.http、javax.ejb等都以interface居多，實現類較少。其實大家真正在用的時候百分之六十以上都在反復的查著javax.servlet.http這個包下面幾個實現類的api函數，其他的包很少問津。筆者建議在學習一種技術之前，對整體的框架有一個了解是很有必要的，J2ee旨在通過interface的聲明來規范實現的行為，任何第三方的廠商想要提供自己品牌的實現前提也是遵循這些接口定義的規則。如果在從前J2se學習的道路上對接口的理解很好的話，這里的體會將是非常深刻的，舉個簡單的例子：

public interface Mp3{
public void play();
public void record();
public void stop();
}

如果我定義這個簡單的接口，發布出去，規定任何第三方的公司想推出自己的名字為Mp3的產品都必須實現這個接口，也就是至少提供接口中方法的具體實現。這個意義已經遠遠不止是面向對象的多態了，只有廠商遵循J2ee的接口定義，世界上的J2ee程序員才能針對統一的接口進行程序設計，最終不用改變代碼只是因為使用了不同廠商的實現類而有不同的特性罷了，本質上說，無論哪一種廠商實現都完成了職責范圍內的工作。這個就是筆者想一直強調的，針對接口編程的思想。

接口到底有什么好處呢？我們這樣設想，現在有AppleMp3、SonyMp3、SamsungMp3都實現了這個Mp3的接口，于是都有了play、 record、stop這三個功能。我們將Mp3產品座位一個組件的時候就不需要知道它的具體實現，只要看到接口定義知道這個對象有3個功能就可以使用了。那么類似下面這樣的業務就完全可以在任何時間從3個品牌擴展到任意個品牌，開個玩笑的說，項目經理高高在上的寫完10個接口里的方法聲明，然后就丟給手下的程序員去寫里面的細節，由于接口已經統一（即每個方法傳入和傳出的格式已經統一），經理只需關注全局的業務就可以天天端杯咖啡走來走去了，^_^：
public Mp3 create();
public void copy(Mp3 mp3);
public Mp3 getMp3();

最后用一個簡單的例子說明接口：一個5號電池的手電筒，可以裝入任何牌子的5號電池，只要它符合5號電池的規范，裝入之后任何看不到是什么牌子，只能感受到手電筒在完成它的功能。那么生產手電筒的廠商和生產5號電池的廠商就可以完全解除依賴關系，可以各自自由開發自己的產品，因為它們都遵守5號電池應有的形狀、正負極位置等約定。這下大家能對接口多一點體會了么？

2. 組件和容器
針對接口是筆者特意強調的J2ee學習之路必備的思想，另外一個就是比較常規的組件和容器的概念了。很多教材和專業網站都說J2EE的核心是一組規范與指南，強調J2ee的核心概念就是組件+容器，這確實是無可厚非的。隨著越來越多的J2ee框架出現，相應的每種框架都一般有與之對應的容器。

容器，是用來管理組件行為的一個集合工具，組件的行為包括與外部環境的交互、組件的生命周期、組件之間的合作依賴關系等等。J2ee包含的容器種類大約有 Web容器、Application Client容器、EJB容器、Applet客戶端容器等。但在筆者看來，現在容器的概念變得有點模糊了，大家耳熟能詳是那些功能強大的開源框架，比如 Hibernate、Struts2、Spring、JSF等，其中Hibernate就基于JDBC的基礎封裝了對事務和會話的管理，大大方便了對數據庫操作的繁瑣代碼，從這個意義上來說它已經接近容器的概念了，EJB的實體Bean也逐漸被以Hibernate為代表的持久化框架所取代。

組件，本意是指可以重用的代碼單元，一般代表著一個或者一組可以獨立出來的功能模塊，在J2ee中組件的種類有很多種，比較常見的是EJB組件、DAO組件、客戶端組件或者應用程序組件等，它們有個共同特點是分別會打包成.war，.jar，.jar，.ear，每個組件由特定格式的xml描述符文件進行描述，而且服務器端的組件都需要被部署到應用服務器上面才能夠被使用。

稍微理解完組件和容器，還有一個重要的概念就是分層模型，最著名的當然是MVC三層模型。在一個大的工程或項目中，為了讓前臺和后臺各個模塊的編程人員能夠同時進行工作提高開發效率，最重要的就是實現層與層之間的耦合關系，許多分層模型的宗旨和開源框架所追求的也就是這樣的效果。在筆者看來，一個完整的 Web項目大概有以下幾個層次：

a) 表示層（Jsp、Html、Javascript、Ajax、Flash等等技術對其支持）
b) 控制層（Struts、JSF、WebWork等等框架在基于Servlet的基礎上支持，負責把具體的請求數據（有時卸載重新裝載）導向適合處理它的模型層對象）
c) 模型層（筆者認為目前最好的框架是Spring，實質就是處理表示層經由控制層轉發過來的數據，包含著大量的業務邏輯）
d) 數據層（Hibernate、JDBC、EJB等，由模型層處理完了持久化到數據庫中）

當然，這僅僅是筆者個人的觀點，僅僅是供大家學習做一個參考，如果要實現這些層之間的完全分離，那么一個大的工程，可以僅僅通過增加人手就來完成任務。雖然《人月神話》中已經很明確的闡述了增加人手并不能是效率增加，很大程度上是因為彼此做的工作有順序上的依賴關系或者說難度和工作量上的巨大差距。當然理想狀態在真實世界中是不可能達到的，但我們永遠應該朝著這個方向去不斷努力。最開始所提倡的針對接口來編程，哪怕是小小的細節，寫一條List list= = new ArrayList()語句也能體現著處處皆使用接口的思想在里面。Anyway，這只是個開篇，筆者會就自己用過的J2ee技術和框架再細化談一些經驗

Java雜談（八）－－Servlet/Jsp
終于正式進入J2ee的細節部分了，首當其沖的當然是Servlet和Jsp了，上篇曾經提到過J2ee只是一個規范和指南，定義了一組必須要遵循的接口，核心概念是組件和容器。曾經有的人問筆者Servlet的Class文件是哪里來的？他認為是J2ee官方提供的，我舉了一個簡單的反例：稍微檢查了一下Tomcat5.0里面的Servlet.jar文件和JBoss里面的Servlet.jar文件大小，很明顯是不一樣的，至少已經說明了它們不是源自同根的吧。其實Servlet是由容器根據J2ee的接口定義自己來實現的，實現的方式當然可以不同，只要都遵守J2ee規范和指南。

上述只是一個常見的誤區罷了，告訴我們要編譯運行Servlet，是要依賴于實現它的容器的，不然連jar文件都沒有，編譯都無法進行。那么Jsp呢？ Java Server Page的簡稱，是為了開發動態網頁而誕生的技術，其本質也是Jsp，在編寫完畢之后會在容器啟動時經過編譯成對應的Servlet。只是我們利用Jsp 的很多新特性，可以更加專注于前后臺的分離，早期Jsp做前臺是滿流行的，畢竟里面支持Html代碼，這讓前臺美工人員可以更有效率的去完成自己的工作。然后Jsp將請求轉發到后臺的Servlet，由Servlet處理業務邏輯，再轉發回另外一個Jsp在前臺顯示出來。這似乎已經成為一種常用的模式，最初筆者學習J2ee的時候，大量時間也在編寫這樣的代碼。

盡管現在做前臺的技術越來越多，例如Flash、Ajax等，已經有很多人不再認為Jsp重要了。筆者覺得Jsp帶來的不僅僅是前后端分離的設計理念，它的另外一項技術成就了我們今天用的很多框架，那就是Tag標簽技術。所以與其說是在學習Jsp，不如更清醒的告訴自己在不斷的理解Tag標簽的意義和本質。

1． Servlet以及Jsp的生命周期
Servlet是Jsp的實質，盡管容器對它們的處理有所區別。Servlet有init()方法初始化，service()方法進行Web服務， destroy()方法進行銷毀，從生到滅都由容器來掌握，所以這些方法除非你想自己來實現Servlet，否則是很少會接觸到的。正是由于很少接觸，才容易被廣大初學者所忽略，希望大家至少記住Servlet生命周期方法都是回調方法。回調這個概念簡單來說就是把自己注入另外一個類中，由它來調用你的方法，所謂的另外一個類就是Web容器，它只認識接口和接口的方法，注入進來的是怎樣的對象不管，它只會根據所需調用這個對象在接口定義存在的那些方法。由容器來調用的Servlet對象的初始化、服務和銷毀方法，所以叫做回調。這個概念對學習其他J2ee技術相當關鍵！

那么Jsp呢？本事上是Servlet，還是有些區別的，它的生命周期是這樣的：
a) 一個客戶端的Request到達服務器 ->
b) 判斷是否第一次調用 -> 是的話編譯Jsp成Servlet
c) 否的話再判斷此Jsp是否有改變 -> 是的話也重新編譯Jsp成Servlet
d) 已經編譯最近版本的Servlet裝載所需的其他Class
e) 發布Servlet，即調用它的Service()方法

所以Jsp號稱的是第一次Load緩慢，以后都會很快的運行。從它的生命的周期確實不難看出來這個特點，客戶端的操作很少會改變Jsp的源碼，所以它不需要編譯第二次就一直可以為客戶端提供服務。這里稍微解釋一下Http的無狀態性，因為發現很多人誤解，Http的無狀態性是指每次一張頁面顯示出來了，與服務器的連接其實就已經斷開了，當再次有提交動作的時候，才會再次與服務器進行連接請求提供服務。當然還有現在比較流行的是Ajax與服務器異步通過 xml交互的技術，在做前臺的領域潛力巨大，筆者不是Ajax的高手，這里無法為大家解釋。

2． Tag標簽的本質
筆者之前說了，Jsp本身初衷是使得Web應用前后臺的開發可以脫離耦合分開有效的進行，可惜這個理念的貢獻反倒不如它帶來的Tag技術對J2ee的貢獻要大。也許已經有很多人開始使用Tag技術了卻并不了解它。所以才建議大家在學習J2ee開始的時候一定要認真學習Jsp，其實最重要的就是明白標簽的本質。

Html標簽我們都很熟悉了，有 <html> 、 <head> 、 <body> 、 <title> ，Jsp帶來的Tag標簽遵循同樣的格式，或者說更嚴格的Xml格式規范，例如 <jsp:include> 、 <jsp:useBean> 、 <c:if> 、 <c:forEach> 等等。它們沒有什么神秘的地方，就其源頭也還是Java Class而已，Tag標簽的實質也就是一段Java代碼，或者說一個Class文件。當配置文件設置好去哪里尋找這些Class的路徑后，容器負責將頁面中存在的標簽對應到相應的Class上，執行那段特定的Java代碼，如此而已。
說得明白一點的話還是舉幾個簡單的例子說明一下吧：

<jsp:include> 去哪里找執行什么class呢?首先這是個jsp類庫的標簽，當然要去jsp類庫尋找相應的class了，同樣它也是由Web容器來提供，例如 Tomcat就應該去安裝目錄的lib文件夾下面的jsp-api.jar里面找，有興趣的可以去找一找啊！

<c:forEach> 又去哪里找呢？這個是由Jsp2.0版本推薦的和核心標記庫的內容，例如 <c:if> 就對應在頁面中做if判斷的功能的一斷Java代碼。它的class文件在jstl.jar這個類庫里面，往往還需要和一個standard.jar類庫一起導入，放在具體Web項目的WEB-INF的lib目錄下面就可以使用了。

順便羅唆一句，Web Project的目錄結構是相對固定的，因為容器會按照固定的路徑去尋找它需要的配置文件和資源，這個任何一本J2ee入門書上都有，這里就不介紹了。了解Tag的本質還要了解它的工作原理，所以大家去J2ee的API里找到并研究這個包：javax.servlet.jsp.tagext。它有一些接口，和一些實現類，專門用語開發Tag，只有自己親自寫出幾個不同功能的標簽，才算是真正理解了標簽的原理。別忘記了自己開發的標簽要自己去完成配置文件，容器只是集成了去哪里尋找jsp標簽對應class的路徑，自己寫的標簽庫當然要告訴容器去哪里找啦。

說了這么多，我們為什么要用標簽呢？完全在Jsp里面來個 <% %> 就可以在里面任意寫Java代碼了，但是長期實踐發現頁面代碼統一都是與html同風格的標記語言更加有助于美工人員進行開發前臺，它不需要懂Java，只要Java程序員給個列表告訴美工什么標簽可以完成什么邏輯功能，他就可以專注于美工，也算是進一步隔離了前后臺的工作吧！

3． 成就Web框架
框架是什么？曾經看過這樣的定義：與模式類似，框架也是解決特定問題的可重用方法，框架是一個描述性的構建塊和服務集合，開發人員可以用來達成某個目標。一般來說，框架提供了解決某類問題的基礎設施，是用來創建解決方案的工具，而不是問題的解決方案。

正是由于Tag的出現，成就了以后出現的那么多Web框架，它們都開發了自己成熟實用的一套標簽，然后由特定的Xml文件來配置加載信息，力圖使得Web 應用的開發變得更加高效。下面這些標簽相應對很多人來說相當熟悉了：
<html:password>
<logic:equal>
<bean:write>
<f:view>
<h:form>
<h:message>

它們分別來自Struts和JSF框架，最強大的功能在于控制轉發，就是MVC三層模型中間完成控制器的工作。Struts-1實際上并未做到真正的三層隔離，這一點在Struts-2上得到了很大的改進。而Jsf向來以比較完善合理的標簽庫受到人們推崇。

今天就大概講這么多吧，再次需要強調的是Servlet/Jsp是學習J2ee必經之路，也是最基礎的知識，希望大家給與足夠的重視！
Java雜談（九）－－Struts

J2ee的開源框架很多，筆者只能介紹自己熟悉的幾個，其他的目前在中國IT行業應用得不是很多。希望大家對新出的框架不要盲目的推崇，首先一定要熟悉它比舊的到底好在哪里，新的理念和特性是什么？然后再決定是否要使用它。

這期的主題是Struts，直譯過來是支架。Struts的第一個版本是在2001年5月發布的，它提供了一個Web應用的解決方案，如何讓Jsp和 servlet共存去提供清晰的分離視圖和業務應用邏輯的架構。在Struts之前，通常的做法是在Jsp中加入業務邏輯，或者在Servlet中生成視圖轉發到前臺去。Struts帶著MVC的新理念當時退出幾乎成為業界公認的Web應用標準，于是當代IT市場上也出現了眾多熟悉Struts的程序員。即使有新的框架再出來不用，而繼續用Struts的理由也加上了一條低風險，因為中途如果開發人員變動，很容易的招進新的會Struts的IT民工啊， ^_^!

     摘要: Web Service概述 Web Service的定義 W3C組織對其的定義如下，它是一個軟件系統，為了支持跨網絡的機器間相互操作交互而設計。Web Service服務通常被定義為一組模塊化的API，它們可以通過網絡進行調用，來執行遠程系統的請求服務。 這里我們從一個程序員的視角來觀察web service。在傳統的程序編碼中，存在這各種的函數方法...  閱讀全文

在前面幾篇文章中都是使用同步方式來調用WebService。也就是說，如果被調用的WebService方法長時間不返回，客戶端將一直被阻塞，直到該方法返回為止。使用同步方法來調用WebService雖然很直觀，但當WebService方法由于各種原因需要很長時間才能返回的話，就會使客戶端程序一直處于等待狀態，這樣用戶是無法忍受的。
??? 當然，我們很容易就可以想到解決問題的方法，這就是多線程。解決問題的基本方法是將訪問WebService的任務交由一個或多個線程來完成，而主線程并不負責訪問WebService。這樣即使被訪問的WebService方法長時間不返回，客戶端仍然可以做其他的工作。我們可以管這種通過多線程訪問WebService的方式稱為異步訪問。
??? 雖然直接使用多線程可以很好地解決這個問題，但比較麻煩。幸好Axis2的客戶端提供了異步訪問WebService的功能。
??? RPCServiceClient類提供了一個invokeNonBlocking方法可以通過異步的方式來訪問WebService。下面先來建立一個WebService。
??? MyService是一個WebService類，代碼如下：

??? 為了模擬需要一定時間才返回的WebService方法，在getName方法中使用了sleep方法來延遲5秒。
??? 下面是MyService類的配置代碼：

??? 從上面的配置代碼可以看出，MyService的配置方式與前幾章的WebService的配置方式完全一樣，也就是說，MyService只是一個普通的WebService。
??? 下面是異步調用MyService的Java客戶端代碼：

??? 從上面的代碼可以看出，invokeNonBlocking方法有三個參數，前兩個參數分別指定了要調用的方法及方法參數的相關信息，而最后一個參數并不是方法返回值的類型信息，而是一個實現org.apache.axis2.client.async.AxisCallback接口的類的對象實例。在本例中隱式實現了AxisCallback接口。在AxisCallback接口中有四個方法需要實現，其中當被異步調用的方法返回時onMessage方法被調用。當運行上面的程序后，將輸出如下的信息：

??? 雖然上面的例子可以實現異步調用，但比較麻煩。為了更方便地實現異步調用，可以使用wsdl2java命令的-a參數生成可異步調用的Stub類。下面的命令可生成同步和異步調用的客戶端代碼（兩個類），其中-s表示生成同步調用代碼，-a表示生成異步調用代碼。

??? 在執行上面的命令后，將生成兩個類：MyServiceStub和MyServiceCallbackHandler類，其中MyServiceStub類負責同步和異步調用WebService，MyServiceCallbackHandler類是一個抽象類，也是一個回調類，當使用異步方式調用WebService方法時，如果方法返回，則MyServiceCallbackHandler類的receiveResultgetName方法被調用。下面是使用MyServiceStub類異步訪問WebService的代碼：

?? 執行上面的程序后，將輸出如下的信息：???

??? ? 在.net中也可以使用異步的方式來調用WebService，如在C#中可使用如下的代碼來異步調用getName方法：

??? 其中async是引用MyService的服務名。要注意的是，在C#中不能在同一個WebService實例的getName方法未返回之前，再次調用該實例的getName方法，否則將拋出異常。如下面的代碼會拋出一個異常：

??? 但不同的WebService實例的方法可以在方法未返回時調用，如下面的代碼是可以正常工作的：

在現今的Web應用中經常使用Spring框架來裝載JavaBean。如果要想將某些在Spring中裝配的JavaBean發布成WebService，使用Axis2的Spring感知功能是非常容易做到的。
??? 在本文的例子中，除了<Tomcat安裝目錄>\webapps\axis2目錄及該目錄中的相關庫外，還需要Spring框架中的spring.jar文件，將該文件復制到<Tomcat安裝目錄>\webapps\axis2\WEB-INF\lib目錄中。
??? 下面先建立一個JavaBean（該JavaBean最終要被發布成WebService），代碼如下：

??? 其中Person也是一個JavaBean，代碼如下：

??? 將上面兩個Java源文件編譯后，放到<Tomcat安裝目錄>\webapps\axis2\WEB-INF\classes目錄中。

??? 在<Tomcat安裝目錄>\webapps\axis2\WEB-INF\web.xml文件中加入下面的內容：

??? 在<Tomcat安裝目錄>\webapps\axis2\WEB-INF目錄中建立一個applicationContext.xml文件，該文件是Spring框架用于裝配JavaBean的配置文件，內容如下：

??? 在applicationContext.xml文件中裝配了service.SpringService類，并被始化了name和job屬性。在配置完SpringService類后，就可以直接在程序中FileSystemXmlApplicationContext類或其他類似功能的類讀取applicationContext.xml文件中的內容，并獲得SpringService類的對象實例。但現在我們并不這樣做，而是將SpringService類發布成WebService。

??? 在<Tomcat安裝目錄>\webapps\axis2\WEB-INF\lib目錄中有一個axis2-spring-1.4.1.jar文件，該文件用于將被裝配JavaBean的發布成WebService。在D盤建立一個axi2-spring-ws目錄，并在該目錄中建立一個META-INF子目錄。在META-INF目錄中建立一個services.xml文件，內容如下：

??? 在Windows控制臺進入axi2-spring-ws目錄，并使用jar命令將axi2-spring-ws目錄中的內容打包成axi2-spring-ws.aar，然后將該文件復制到<Tomcat安裝目錄>\webapps\axis2\WEB-INF\services目錄中，啟動Tomcat后，就可以訪問該WebService了，訪問方式與前面幾篇文章的訪問方式相同。獲得wsdl內容的URL如下：

http://localhost:8080/axis2/services/springService?wsdl

??? 在將Spring中的裝配JavaBean發布成WebService需要注意以下幾點：

??? 1.?由JavaBean編譯生成的.class文件需要放在WEB-INF\classes目錄中，或打成.jar包后放在WEB-INF\lib目錄中，而WEB-INF\services目錄中的.aar包中不需要包含.class文件，而只需要包含一個META-INF目錄，并在該目錄中包含一個services.xml文件即可。

??? 2.?services.xml的配置方法與前幾篇文章的配置方法類似，只是并不需要使用ServiceClass參數指定要發布成WebService的Java類，而是要指定在applicationContext.xml文件中的裝配JavaBean的名稱（SpringBeanName參數）。

??? 3.?在services.xml文件中需要通過ServiceObjectSupplier參數指定SpringServletContextObjectSupplier類來獲得Spring的ApplicationContext對象...

在 《WebService大講堂之Axis2(5)：會話（Session）管理》 一文中介紹了如何使用Axis2來管理同一個服務的會話，但對于一個復雜的系統，不可能只有一個WebService服務，例如，至少會有一個管理用戶的WebService（用戶登錄和注冊）以及處理業務的WebService。象這種情況，就必須在多個WebService服務之間共享會話狀態，也稱為跨服務會話(Session)管理。實現跨服務會話管理與實現同一個服務的會話管理的步驟類似，但仍然有一些差別，實現跨服務會話管理的步驟如下：

實現跨服務的Session管理需要如下三步：

1.?使用MessageContext和ServiceGroupContext獲得與設置key-value對。

2.?為要進行Session管理的WebService類所對應的<service>元素添加一個scope屬性，并將該屬性值設為application。

3.?在客戶端使用setManageSession(true)打開Session管理功能。

從上面的步驟可以看出，實現跨服務會話管理與實現同一個服務的會話管理在前兩步上存在著差異，而第3步是完全一樣的。下面是一個跨服務的會話管理的實例。在這個例子中有兩個WebService類：LoginService和SearchService，代碼如下：

LoginService.java

SearchService.java

services.xml文件中的配置代碼如下：

第3步與《WebService大講堂之Axis2(5)：會話（Session）管理》一文中介紹的方法類似。

下面是使用兩個stub類的對象實例訪問上面實現的兩個WebService的客戶端代碼：

在執行上面的代碼后，將輸出如下的信息：

讀者可以將scope屬性值改成transportsession，看看會輸出什么！

??? 實際上，Axis2的會話管理也是通過Cookie實現的，與Web應用中的Session管理類似。如果讀者使用C#訪問支持會話（在同一個服務中的會話管理）的WebService，需要指定一個CookieContainer對象，代碼如下：

如果是訪問跨服務的支持會話的WebService，則不需要指定CookieContainer對象，代碼如下：

如果讀者使用delphi（本文使用的是delphi2009，其他的delphi版本請讀者自行測試）調用支持會話的WebService時有一些差別。經筆者測試，使用delphi調用WebService，將scope屬性值設為transportsession和application都可以實現跨服務的會話管理，這一點和Java與C#不同，Java和C#必須將scope屬性值設為application才支持跨服務會話管理。在delphi中不需要象C#指定一個CookieContainer或其他類似的對象，而只需要象訪問普通的WebService一樣訪問支持會話的WebService即可。

WebService給人最直觀的感覺就是由一個個方法組成，并在客戶端通過SOAP協議調用這些方法。這些方法可能有返回值，也可能沒有返回值。雖然這樣可以完成一些工具，但這些被調用的方法是孤立的，當一個方法被調用后，在其他的方法中無法獲得這個方法調用后的狀態，也就是說無法保留狀態。

讀者可以想象，這對于一個完整的應用程序，無法保留狀態，就意味著只依靠WebService很難完成全部的工作。例如，一個完整的應用系統都需要進行登錄，這在Web應用中使用Session來保存用戶登錄狀態，而如果用WebService的方法來進行登錄處理，無法保存登錄狀態是非常令人尷尬的。當然，這也可以通過其他的方法來解決，如在服務端使用static變量來保存用戶狀態，并發送一個id到客戶端，通過在服務端和客戶端傳遞這個id來取得相應的用戶狀態。這非常類似于Web應用中通過Session和Cookie來管理用戶狀態。但這就需要由開發人員做很多工作，不過幸好Axis2為我們提供了WebService狀態管理的功能。

使用Axis2來管理WebService的狀態基本上對于開發人員是透明的。在WebService類需要使用org.apache.axis2.context.MessageContext和org.apache.axis2.context.ServiceContext類來保存與獲得保存在服務端的狀態信息，這有些象使用HttpSession接口的getAttribute和setAttribute方法獲得與設置Session域屬性。

除此之外，還需要修改services.xml文件的內容，為<service>元素加一個scope屬性，該屬性有四個可取的值：Application, SOAPSession, TransportSession, Request，不過要注意一下，雖然Axis2的官方文檔將這四個值的單詞首字母和縮寫字母都寫成了大寫，但經筆者測試，必須全部小寫才有效，也就是這四個值應為：application、soapsession、transportsession、request，其中request為scope屬性的默認值。讀者可以選擇使用transportsession和application分別實現同一個WebService類和跨WebService類的會話管理。

在客戶端需要使用setManageSession(true)打開Session管理功能。

綜上所述，實現同一個WebService的Session管理需要如下三步：

1.?使用MessageContext和ServiceContext獲得與設置key-value對。

2.?為要進行Session管理的WebService類所對應的<service>元素添加一個scope屬性，并將該屬性值設為transportsession。

3.?在客戶端使用setManageSession(true)打開Session管理功能。

下面是一個在同一個WebService類中管理Session的例子。

先建立一個WebService類，代碼如下：

在LoginService類中有兩個方法：login和getLoginMsg，如果login方法登錄成功，會將“成功登錄”字符串保存在ServiceContext對象中。如果在login方法返回true后調用getLoginMsg方法，就會返回“成功登錄”。

下面是LoginService類的配置代碼（services.xml）：

使用如下的命令生成客戶端使用的stub類：

在stub\src\client目錄中生成了一個LoginServiceStub.java類，在該類中找到如下的構造句方法：

在該方法中最后添加如下的代碼：

下面的客戶端代碼使用LoginServiceStub對象訪問了剛才建立的WebService：

運行上面的代碼后，會輸出“成功登錄”信息。

在《 WebService大講堂之Axis2（2）：復合類型數據的傳遞 》中講過，如果要傳遞二進制文件（如圖像、音頻文件等），可以使用byte[]作為數據類型進行傳遞，然后客戶端使用RPC方式進行調用。這樣做只是其中的一種方法，除此之外，在客戶端還可以使用wsdl2java命令生成相應的stub類來調用WebService，wsdl2java命令的用法詳見《WebService大講堂之Axis2（1）：用POJO實現0配置的WebService》。
??? WebService類中包含byte[]類型參數的方法在wsdl2java生成的stub類中對應的數據類型不再是byte[]類型，而是javax.activation.DataHandler。DataHandler類是專門用來映射WebService二進制類型的。
??? 在WebService類中除了可以使用byte[]作為傳輸二進制的數據類型外，也可以使用javax.activation.DataHandler作為數據類型。不管是使用byte[]，還是使用javax.activation.DataHandler作為WebService方法的數據類型，使用wsdl2java命令生成的stub類中相應方法的類型都是javax.activation.DataHandler。而象使用.net、delphi生成的stub類的相應方法類型都是byte[]。這是由于javax.activation.DataHandler類是Java特有的，對于其他語言和技術來說，并不認識javax.activation.DataHandler類，因此，也只有使用最原始的byte[]了。
??? 下面是一個上傳二進制文件的例子，WebService類的代碼如下：

上面代碼在services.xml文件的配置代碼如下：

??? 如果使用wsdl2java命令生成調用Java客戶端代碼，則需要創建DataHandler類的對象實例，代碼如下：

wsdl2java命令會為每一個方法生成一個封裝方法參數的類，類名為方法名（第一個字符大寫），如uploadWithByte方法生成的類名為UploadWithByte。如果要設置file參數的值，可以使用UploadWithByte類的setFile方法，代碼如下：

最后是調用uploadWithByte方法，代碼如下（FileServiceStub為wsdl2java生成的stub類名）：

如果使用C#調用FileService，則file參數類型均為byte[]，代碼如下：

其中picUpdateImage為c#中加載圖像文件的picturebox控件。

用Axis2實現Web Service，雖然可以將POJO類放在axis2\WEB-INF\pojo目錄中直接發布成Web Service，這樣做不需要進行任何配置，但這些POJO類不能在任何包中。這似乎有些不方便，為此，Axis2也允許將帶包的POJO類發布成Web Service。
??? 先實現一個POJO類，代碼如下：

這個類有兩個方法，這兩個方法都需要發布成Web Service方法。這種方式和直接放在pojo目錄中的POJO類不同。要想將MyService類發布成Web Service，需要一個services.xml文件，這個文件需要放在META-INF目錄中，該文件的內容如下：

其中<service>元素用于發布Web Service，一個<service>元素只能發布一個WebService類，name屬性表示WebService名，如下面的URL可以獲得這個WebService的WSDL內容：

http://localhost:8080/axis2/services/myService?wsdl

其中name屬性名就是上面URL中"?"和"/"之間的部分。

<description>元素表示當前Web Service的描述，<parameter>元素用于設置WebService的參數，在這里用于設置WebService對應的類名。在這里最值得注意的是<messageReceivers>元素，該元素用于設置處理WebService方法的處理器。例如，getGreeting方法有一個返回值，因此，需要使用可處理輸入輸出的RPCMessageReceiver類，而update方法沒有返回值，因此，需要使用只能處理輸入的RPCInOnlyMessageReceiver類。

使用這種方式發布WebService，必須打包成.aar文件，..aar文件實際上就是改變了擴展名的.jar文件。在現在建立了兩個文件：MyService.java和services.xml。將MyService.java編譯，生成MyService.class。services.xml和MyService.class文件的位置如下：

D:\ws\service\MyService.class

D:\ws\META-INF\services.xml

??? 在windows控制臺中進入ws目錄，并輸入如下的命令生成.aar文件（實際上，.jar文件也可以發布webservice，但axis2官方文檔中建議使用.aar文件發布webservice）：

jar cvf ws.aar .

??? 最后將ws.aar文件復制到<Tomcat安裝目錄>\webapps\axis2\WEB-INF\services目錄中，啟動Tomcat后，就可以調用這個WebService了。調用的方法和《WebService大講堂之Axis2（1）：用POJO實現0配置的WebService》所講的方法類似。

另外services.xml文件中也可以直接指定WebService類的方法，如可以用下面的配置代碼來發布WebService：

上面的配置代碼前面的部分和以前的services.xml文件的內容相同，但后面使用了<operation>元素來指定每一個WebService方法，并單獨指定了處理每一個方法的處理器。對于客戶端來說，調用使用這兩個services.xml文件發布的WebService并沒有太大我區別，只是使用第二個services.xml文件發布WebServices后，在使用wsdl2java命令或使用C#、delphi等生成客戶端的stub時，update方法的String類型被封裝在了update類中，在傳遞update方法的參數時需要建立update類的對象實例。而使用第一個services.xml文件發布的WebService在生成stub時直接可以為update方法傳遞String類型的參數。從這一點可以看出，這兩種方法生成的WSDL有一定的區別。但實際上，如果客戶端程序使用第一個services.xml文件發布的WebService生成stub類時（這時update方法的參數是String），在服務端又改為第二個services.xml文件來發布WebService，這時客戶端并不需要再重新生成stub類，而可以直接調用update方法。也就是說，服務端使用什么樣的方式發布WebService，對客戶端并沒有影響。

如果想發布多個WebService，可以使用<serviceGroup>元素，如再建立一個MyService1類，代碼如下：

在services.xml文件中可以使用如下的配置代碼來配置MyService和MyService1類：

在實際的應用中，不僅需要使用WebService來傳遞簡單類型的數據，有時也需要傳遞更復雜的數據，這些數據可以被稱為復合類型的數據。數組與類（接口）是比較常用的復合類型。在Axis2中可以直接使用將WebService方法的參數或返回值類型聲明成數組或類（接口）。但要注意，在定義數組類型時只能使用一維數組，如果想傳遞多維數組，可以使用分隔符進行分隔，如下面的代碼所示：

String[] strArray = new String[]{ "自行車,飛機,火箭","中國,美國,德國", "超人,蜘蛛俠,鋼鐵俠" } ;

??? 上面的代碼可以看作是一個3*3的二維數組。

??? 在傳遞類的對象實例時，除了直接將數組類型聲明成相應的類或接口，也可以將對象實例進行序列化，也就是說，將一個對象實例轉換成字節數組進行傳遞，然后接收方再進行反序列化，還原這個對象實例。

??? 下面的示例代碼演示了如何傳遞數組與類（接口）類型的數據，并演示如何使用字節數組上傳圖像。本示例的客戶端代碼使用Java和C#編寫。要完成這個例子需要如下幾步：

一、實現服務端代碼

??? ComplexTypeService是一個WebService類，該類的代碼如下：

?

二、實現DataForm類

??? DataForm是要返回的對象實例所對應的類，該類的實現代碼如下：

三、發布WebService

??? 由于本示例的WebService類使用了一個Java類（DataForm類），因此，在發布WebService之前，需要先將DataForm.class文件復制到<Tomcat安裝目錄>\webapps\axis2\WEB-INF\classes\data目錄中，然后將ComplexTypeService.class文件復制到<Tomcat安裝目錄>\webapps\axis2\WEB-INF\pojo目錄中，最后啟動Tomcat（如果Tomcat已經啟動，由于增加了一個DataForm類，因此，需要重新啟動Tomcat）。

四、使用Java編寫調用WebService的客戶端代碼

??? 在客戶端仍然使用了RPC的調用方式，代碼如下：

??? 運行上面的程序，將輸出如下的內容：

五、使用C#編寫調用WebService的客戶端代碼

??? 在Visual Studio中使用WebService就簡單得多。假設引用WebService時的引用名為complexType，則下面的代碼調用了uploadImageWithByte方法來上傳圖像文件。在Visual Studio引用WebService時，uploadImageWithByte方法多了兩個out參數，在使用時要注意。

??? 在獲得二維數組時，可以將數據加載到DataGridView或其他類似的控件中，代碼如下：

??? 向DataGridView控件添加數據后的效果如圖1所示。

??? 對于其他的WebService方法的調用都非常簡單，讀者可以自己做這個實驗。

??? 要注意的是，由于.net和java序列化和反序列化的差異，通過序列化的方式傳遞對象實例只使用于客戶端與服務端為同一種語言或技術的情況，如客戶端和服務端都使用Java來編寫。

??? 如果讀者要上傳大文件，應盡量使用FTP的方式來傳遞，而只通過WebService方法來傳遞文件名等信息。這樣有助于提高傳輸效率。