筆記

1. Code first approach:可能不能完全發揮框架和web services的能量，但能完成目標。減少了學習曲線，不用非常透徹了解web services概念，只要對某個框架有一定了解就能完成任務。
2.Contract first approach:根據服務先寫WSDL文件，寫好之后使用框架的工具把WSDL轉換為依賴框架的代碼。

一  介紹

當客戶端調用你的web service的時候，他會發送一個消息過來（可能是soap 消息），如：

<foo:concatRequest>
<s1>abc</s1>
<s2>123</s2>
</foo:concatRequest>

這時候如果有一個轉換器把這個soap消息轉換成java對象，然后調用你提供的java對象（方法）的話將會是非常方便的。幾個最流行的庫就是充當了這種轉換器功能，比如CXF, Axis2 ， Metro （jdk6自帶的有）。

手動創建WSDL文件比較容易出錯，可以使用eclipse進行可視化編輯。

二 生成服務代碼

像CXF這樣的 web service庫可以創建轉換器把進來的SOAP 消息轉換為Java對象，然后作為參數傳給方法。生成這些代碼，只需創建一個main：

1 CXF方式：

public static void main(String[] args) {
    WSDLToJava.main(new String[] {
    "-server",
    "-d", "src/main/java",
    "src/main/resources/SimpleService.wsdl" });
    System.out.println("Done!");
}

運行后會生成service endpoint interface（SEI），我們再寫一個類（比如SimpleServiceImpl）來實現這個接口，寫入自己的業務。還會生成傳入消息對應的java對象。同時生成一個服務器類：

public class SimpleService_P1_Server {
    protected SimpleService_P1_Server() throws Exception {
        System.out.println("Starting Server");
        Object implementor = new SimpleServiceImpl();
        String address = "http://localhost:8080/ss/p1";
        Endpoint.publish(address, implementor);
    }
    public static void main(String args[]) throws Exception {
        new SimpleService_P1_Server();
        System.out.println("Server ready...");
        Thread.sleep(5 * 60 * 1000);
        System.out.println("Server exiting");
        System.exit(0);
    }
}

運行這個類你的web service就可以服務了。

2 Axis2 方式

用類似的寫main方法，或者配置eclipse的axis2插件可生成：在WSDL文件上，右鍵->web service->generate java bean skeleton

界面的上半部分針對服務端，可以根據需要調整生成的級別，下半部分是生成客戶端。具體的級別可參考eclipse的幫助文檔。一路下一步，最后根據命名空間生成包路徑的文件，里面有XXSkeletonInterface.java 文件（如果生成的時候選擇了生成接口的話），還有一個XXSkeleton實現了這個接口，也是我們需要修改這部分代碼完成我們業務的地方。實際上有一個XXMessageReceiverInOut.java的類接收請求的消息，并調用XXSkeletonInterface。使用eclipse的axis2插件的時候，會自動在web-inf文件夾下生成service\xx(你的wsdl服務名)，這下面還要一個meta-inf文件夾裝有wsd文件和一個services.xml配置文件。services.xml文件可配置包括XXMessageReceiverInOut類在內的選項。

二 生成客戶端代碼

為了調用這些web service，同樣可以用CXF這些庫來生成在客戶端運行的轉換器（稱為service stub）。當調用stub里的方法的時候，他會把你的數據/對象 轉換為正確的XML格式，然后發送給真正的web service。當他收到響應的時候，又會把XML轉回Java。

1 CXF 方式

和生成服務器端類似，使用方法

WSDLToJava.main(new String[] {
"-client",
"-d", "src/main/java",
"src/main/resources/SimpleService.wsdl" });

運行后會生成客戶端代碼：

public final class SimpleService_P1_Client {
    private static final QName SERVICE_NAME = new QName("http://ttdev.com/ss",
        "SimpleService");
    private SimpleService_P1_Client() {} 

    public static void main(String args[]) throws Exception {
        URL wsdlURL = SimpleService_Service.WSDL_LOCATION;
        if (args.length > 0) {
            File wsdlFile = new File(args[0]);
            try {
                if (wsdlFile.exists()) {
                wsdlURL = wsdlFile.toURI().toURL();
            } else {
                wsdlURL = new URL(args[0]);
            }
            } catch (MalformedURLException e) {
                e.printStackTrace();
            }
        } 
        SimpleService_Service ss =
        new SimpleService_Service(wsdlURL, SERVICE_NAME);
        SimpleService port = ss.getP1();
        {
            System.out.println("Invoking concat...");
            com.ttdev.ss.ConcatRequest _concat_parameters = null;
            java.lang.String _concat__return = port.concat(_concat_parameters);
            System.out.println("concat.result=" + _concat__return);
        } 
        System.exit(0);
    }
}

SimpleService_Service是創建的service stub，他模擬了客戶端的服務。我們需要修改這個類中的_concat_parameters部分，加入參數：

com.ttdev.ss.ConcatRequest _concat_parameters = new ConcatRequest();
_concat_parameters.setS1("abc");
_concat_parameters.setS2("123");

現在就可以運行客戶端代碼了。SEI中有一些注解，可以修改，不細說。

有兩種SOAP message風格，document 和RPC，他們定義了SOAP message body的格式。使用document風格時（包括wrapped和unwrapped），在wsdl中有一個非空的types部分，這個部分用XML Schema language定義了web service要用到的類型。wsgen工具從SIB（有SEI就足夠了）中生成與XSD對應的java類。用java代碼生成WSDL文件的時候需要一些java類，wsgen工具可以生成這些Java類，生成的這些java類被稱為wsgen artifacts，底層的JWS類庫會用到這些類，特別是JAX-B系列的包，會用來轉換(marshal)java類實例(that is, Java in-memory objects)為XML類型的XML實例（滿足XML Schema document的XML文檔實例），

The inverse operation is used to convert (unmarshal) an XML document instance to an in-memory
object, an object of a Java type or a comparable type in some other language。因此wsgen工具生成的artifacts，支持了Java為基礎的web service的互操作性。JAX-B類庫提供了Java和XSD類型轉換的底層支持。

For the most part, the wsgen utility can be used without our bothering to inspect the artifacts that it produces. For the most part, JAX-B remains unseen infrastructure.

wsgen artifacts實際上是wsdl message的數據類型，他們和XML Schema type綁定，每個message的XML Schema types從這些java類型得來的。注：在當前的jdk1.6.24中，已經融入wsgen自動生成的過程，不需手動調用。

wsgen工具可用來生成wsdl文件，如：% wsgen -cp "." -wsdl ch01.ts.TimeServerImpl 。這為TimeServer服務生成了wsdl。用wsgen生成的wsdl和通過訪問發布的服務生成的wsdl 有個很大的區別：wsgen生成的沒有endpoint,因為這個URL是在發布服務的時候決定的。其他地方兩個wsdl是相同的。

wsimport(以前叫wsdl2java和 java2wsdl更形象)工具可使用WSDL生成用來幫助寫客戶端的artifacts .

1 先契約再編碼方式
一個例子：得到一個tempConvert.wsdl文件，使用命令 wsimport -keep -p ch02.tc tempConvert.wsdl ，命令根據wsdl的portType生成一個SEI類，把SEI的interface換為class，再把方法改為實現就可變為SIB。把該SIB發布，再使用命令wsimport -keep -p clientTC http://localhost:5599/tc?wsdl，來生成客戶端輔助類
2 編碼優先
服務被發布之后，會自動生成WSDL供客戶端使用。然而，使用annotations可以控制WSDL或WSDL-generated artifacts的生成。

DTDs

Introduced as part of the XML 1.0 specification, DTDs are the oldest constraint model around in the XML world. They're simply to use, but this simplicity comes at a price: DTDs are inflexible, and offer you little for data type validation as well.

XML Schema (XSD)

XML Schema is the W3C's anointed successor to DTDs. XML Schemas are literally orders of magnitude more flexible than DTDs, and offer an almost dizzying array of support for various data types. However, just as DTDs were simple and limited, XML Schemas are flexible, complex, and (some would argue) bloated. It takes a lot of work to write a good schema, even for 50- or 100-line XML documents. For this reason, there's been a lot of dissatisfaction with XML Schema, even though they are widely being used.

[prefix]:[element name]

元素：
root元素必須包含所有文檔中的元素，只能有一個root元素。元素名只能以下劃線或字母開頭，不能有空格，區分大小寫。開元素必須有對應閉元素（也有類似html的簡寫，如<img src="/images/xml.gif" />）。文檔由DTD或schema來限制它是否合格。

屬性：
什么時候用屬性？基本原則：多個值的數據用元素，單值的數據用元素。如果數據有很多值或者比較長，數據最可能屬于元素。他主要被當作文本，容<rss:author>Doug Hally</rss:author> <journal:author>Neil Gaiman</journal:author>易搜索，好用。比如一本書的章節描述。然而如果數據主要作為單值處理的話，最好作為屬性。如果搞不清楚，可以安全的使用元素。

命名空間Namespaces：
xml的命名空間是一種用一個特定的URI來關聯XML文檔里的一個或多個元素的方法。意味著元素是由名字和命名空間一起來識別的。許多復雜的XML文件里，同一個名字會有多個用途。比如，一個RSS feed有一個作者，這個作者同時是每個日記的。雖然這些數據都用author元素來表示，但他們不應該被當作同一個類型的數據。命名空間很好的解決了這個問題，命名空間說明書要求一個前綴和唯一的URI聯合起來區分不同命名空間里的元素。如http://www.neilgaiman.com/entries作為URI，聯合前綴journal用來表示日志相關的元素。
<rdf:RDF xmlns:rss="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:journal="http://www.neilgaiman.com/entries">，然后就可使用了：
<rss:author>Doug Hally</rss:author> <journal:author>Neil Gaiman</journal:author>實際上在使用命名空間前綴的時候再定義也可以的：
<rss:author xmlns:rss="http://www.w3.org/1999/02/22-rdf-syntax-ns#">Doug Hally</rss:author>
如果名字沒有命名空間，不代表在默認命名空間中，而是xml處理器以在任何命名空間以外方式解釋他。要聲明默認命名空間的話就不用后面冒號部分，如<Insured xmlns="使用的一些術語:

• The name of a namespace (such as http://www.ibm.com/software) is the namespace URI.

• The element or attribute name can include a prefix and a colon (as in prod:Quantity). A name in that form is called a qualified name, or QName, and the identifier that follows the colon is called a local name. If a prefix is not in use, neither is the colon, and the QName and local name are identical.

• An XML identifier (such as a local name) that has no colon is sometimes called an NCName. (The NC comes from the phrase no colon.)

Entity references:
用來處理轉義字符，語法是& [entity name] ;XML解析器碰到這種entity reference，就會用對應的值替換掉他。如&lt;（<）,&gt;(>),&amp;(&),&quot;("),&apos;(')。注意entity reference是用戶可定義的。比如多處用到版權提示，自己定義后以后更改就方便了：<ora:copyright>&OReillyCopyright;</ora:copyright>。除了用來表示數據中的復雜或特殊字符外，entity reference還會有更多用途。

不解析的數據：
當傳輸大量數據給應用且不用xml解析的時候，CDATA就有用了。當大量的字符需要用entity reference轉義的時候，或空格必須保留的時候，使用CDATA。<![CDATA[….]]>

31
while (i != 0)
    i >>>= 1; //無符號右移，不管正負左邊都是補0
為了表達式合法，這里的i必須是整型(byte, char, short, int, or long)。謎題的關鍵在于>>>= 是一個復合賦值操作符，不幸的是復合賦值操作符會默默的做narrowing primitive conversions，即從一個數據類型轉換為一個更小的數據類型。Narrowing primitive conversions can lose information about the magnitude or precision of numeric values。為了使問題更具體，假設這樣定義：
short i = -1; 因為初始值i ((short)0xffff) 非零，循環執行。第一步位移會把i提升為int。short, byte, or char類型的操作數都會做這樣的操作。這是widening primitive conversion，沒有信息丟失。這種提升有符號擴展，因此結果是int值0xffffffff。無符號右移一位產生int值0x7fffffff。為了把int值存回short變量，Java執行了可怕的narrowing primitive conversion,即簡單去掉高十六位。這樣又變回了(short)0xffff。如果定義類似short or byte型的負數，都會得到類似結果。你如果定義的是char話，則不會無限循環，因為char值非負，位移之前的寬擴展不會做符號擴展。

總結：不要在short, byte, or char變量上使用復合賦值操作符。這種表達式進行混合類型計算，非常容易混淆。更糟糕的是隱含的窄映射會丟掉信息。

32
while (i <= j && j <= i && i != j) {}
i <= j and j <= i, surely i must equal j？對于實數來說是這樣的。他非常重要，有個名稱：The ≤ relation on the real numbers is said to be antisymmetric。Java's <= operator used to be antisymmetric before release 5.0, but no longer.Java 5之前數據比較符號(<, <=, >, and >=) 需要兩邊的操作數必須為基礎類型(byte, char, short, int, long, float, or double).在Java 5變為兩邊操作數為凡是可轉變為基礎類型的類型。java 5引入autoboxing and auto-unboxing 。The boxed numeric types are Byte, Character, Short, Integer, Long, Float, and Double。具體點，讓上面進入無限循環：
Integer i = new Integer(0);
Integer j = new Integer(0);
(i <= j and j <= i) perform unboxing conversions on i and j and compare the resulting int values numerically。i和j表示0，所以表達式為true。i != j比較的是對象引用，也為true。很奇怪規范沒有把等號改為比較值。原因很簡單：兼容性。當一種語言廣泛應用的時候，不能破壞已存在的規范來改變程序的行為。System.out.println(new Integer(0) == new Integer(0));總是輸出false，所以必須保留。當一個是boxed numeric 類型，另一個是基本類型的時候可以值比較。因為java 5之前這是非法的，具體點：
System.out.println(new Integer(0) == 0); //之前的版本非法，Java 5輸出True
總結：當兩邊的操作數是boxed numeric類型的時候，數字比較符和等于符號是根本不同的：數字比較符是值比較，等號比較的是對象引用。

33
while (i != 0 && i == -i) {}
有負號表示i一定是數字，NaN不行，因為他不等于任何數。事實上，沒有實數可以出現這種情況。但Java的數字類型并沒有完美表達實數。浮點數由一個符號位，一個有效數字（尾數），一個指數構成。浮點數只有0才會和自己的負數相等，所以i肯定是整數。有符號整數用的是二進制補碼計算：取反加一。補碼的一大優勢是用一個唯一的數來表示0。然而有一個對應的缺點：本來可表達偶數個值，現在用一個表達了0，剩下奇數個來表示正負數，意味著正數和負數的數量不一樣。比如int值，他的Integer.MIN_VALUE（-2³¹）。十六進制表達0x8000000。通過補碼計算可知他的負數仍然不變。對他取負數是溢出了的，不過Java在整數計算中忽略了溢出。
總結：Java使用二進制補碼，是不對稱的。有符號整數(int, long, byte, and short) 負數值比整數值多一個。

34
        final int START = 2000000000;
        int count = 0;
        for (float f = START; f < START + 50; f++)
            count++;
        System.out.println(count);
注意循環變量是float。回憶謎題28 ，明顯f++沒有任何作用。f的初始化值接近Integer.MAX_VALUE，因此需要31位來準確表達，但是float類型只提供了24位精度。增加這樣大的一個float值不會改變值。看起來會死循環？運行程序會發現，輸出0。循環中f和(float)(START + 50)做比較。但int和float比較的時候，自動把int先提示為float。不幸的是三個會引起精度丟失的寬基本類型轉換的其中之一（另外兩個是long到float，long到double）。f的初始值巨大，加50再轉換為float和直接把f轉換為float是一樣的效果，即(float)2000000000 == 2000000050，所以f < START + 50 失敗。只要把float改為int即可修正。
     沒有計算器，你怎么知道 2,000,000,050 和float表示2,000,000,000一樣？……
The moral of this puzzle is simple: Do not use floating-point loop indices, because it can lead to unpredictable behavior. If you need a floating-point value in the body of a loop, take the int or long loop index and convert it to a float or double. You may lose precision when converting an int or long to a float or a long to a double, but at least it will not affect the loop itself. When you use floating-point, use double rather than float unless you are certain that float provides enough precision and you have a compelling performance need to use float. The times when it's appropriate to use float rather than double are few and far between。

35
下面程序模擬一個簡單的時鐘
int minutes = 0;
for (int ms = 0; ms < 60*60*1000; ms++)
  if (ms %  60*1000 == 0)
     minutes++;
 System.out.println(minutes);
結果是60000，問題在于布爾表達式ms % 60*1000 == 0，最簡單的修改方法是：if (ms % (60 * 1000) == 0)
更好的方法是用合適命名的常量代替魔力數字：

private static final int MS_PER_HOUR = 60 * 60 * 1000;
private static final int MS_PER_MINUTE = 60 * 1000;
public static void main(String[] args) {
   int minutes = 0;
   for (int ms = 0; ms < MS_PER_HOUR; ms++)
     if (ms % MS_PER_MINUTE == 0)
        minutes++;
    System.out.println(minutes);
}
絕不要用空格來分組；使用括號來決定優先級