笔记

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="http://www.IBM.com/software"> 
使用的一些术语:

• 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);
}
绝不要用空格来分组；使用括号来决定优先级