笔记

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

What Is JDBC ？

  JDBC 是java编程中一系列允许简单连接到很多数据库（特别是关系型数据库）编程APIs . In Java 2 Platform, Standard Edition (J2SE) 5.0,
JDBC API 由两个包定义:

java.sql ：提供java访问处理贮存在数据源（特别是关系型数据库）中的数据，有最基础常用的对象如Connection, ResultSet, Statement, and PreparedStatement。这个包j2se 和j2ee平台都可使用。

javax.sql：提供java访问处理服务器端数据源。这个包给j2ee提供服务，如DataSource 和RowSet。

ODBC bridge是以ODBC标准 C API 方式实现JDBC 的库。

简而言之，JDBC是一个和database-independent 的访问数据库的API。

DriverManager是唯一可以创建数据库连接的类。DriverManager根据各个厂商（如Oracle, MySQL, and Sybase）提供的驱动创建数据库。

What Is ODBC ？

  Open Database Connectivity (ODBC) 是一种来自微软的编程接口，他为Windows应用程序访问网络上数据库提供了通用语言。 ODBC is a C-based interface
to SQL-based database systems. It provides a consistent interface for communicating with a database and for accessing database metadata (information about the database system vendor and how the tables, views, and data are stored).ODBC作为标准出现。厂商为各自的DBMS提供了各种的驱动或bridges。从java客户端访问ODBC-based数据库，可以使用JDBC-ODBC bridge，因此可以使用JDBC-ODBC bridge访问支持ODBC的数据库，比如Microsoft Access。微软为他的操作系统提供ODBC driver manager。ODBC driver manager协调访问ODBC驱动和对应的数据源。

问题：如果用c++写数据库客户端，你不得不在另一平台重新写客户端；PC版的不能在Macintosh上运行。两个原因：1.c++不是跨平台的，很多东西没有特别指定（如int型用多少位表示）2 更重要的是，想网络访问，GUI框架库等在各个平台不同。ODBC的另一个问题是，接口复杂学习时间长。JDBC去除了这些问题，为访问关系数据库引入平台无关的解决方案。因为性能问题和缺少事务支持, JDBC-ODBC bridge 驱动只适合实验用或没有其他可选方法。

What Is a JDBC-ODBC Bridge?

   简而言之，JDBC-ODBC bridge通过大多数ODBC驱动来提供JDBC访问。它是一个把JDBC操作转换为ODBC操作的JDBC驱动。（ODBC操作是由 C-based libraries实现的——ODBC功能仍然在二进制代码库中；如果数据库或硬件平台更换，需要替换ODBC库）。brige作为sun.jdbc.odbc包实现，包含一个native library用来访问ODBC。sun.jdbc.odbc包在/jre/lib/rt.jar中，包含一个sun.jdbc.odbc.JdbcOdbcDriver类，用来JDBC驱动。注意，JDBC-ODBC bridge是一种“万能”的方式，因此可能比一些特别设计的JDBC驱动慢。

SQL is a Data Manipulation Language (DML—影响数据库对象内容的命令集) and a Data Definition Language (DDL—影响数据库对象结构的命令集).SQL also 提供控制事务命令 (such as commit and rollback)

连接jdbc的过程参考JDBC加载分析 。总之JDBC驱动的作用是提供各种数据库的具体实现(实现了java.sql.Driver接口)，隐藏具体数据库的细节（每个数据库厂商可能会为同一个数据库提供不止一个驱动，这些效率，价格/性能会有不同）。

在fianlly中立刻关闭/释放 JDBC资源(such as the ResultSet, Statement, PreparedStatement, and Connection objects)，而不是等他们自己关闭，会改进应用程序的性能。写一个工具类释放这些资源是一个好办法。

JDBC API主要用来传SQL statement给数据库，但也能读写表格式数据源的数据，这种来自javax.sql.RowSet组接口的读写能力可以被定制去使用更新spreadsheet,flat file 类似表格式数据源的数据。

JDBC有四种类型的驱动连接数据库。

异常：SQLException:有getNextException()可以链接一系列异常，还有很多方法可以展示额外的错误/异常信息。SQLWarning:SQLException的子类，表示非致命可忽略BatchUpdateException:批量更新时出现的错误，除了SQLException提供的信息，还有错误发生前已成功执行多少条数据DataTruncation:意外truancate 数据抛出。

Java Naming and Directory Interface (JNDI) is an API that supports accessing naming and directory services in Java programs.

命名服务目的：把命名和对象联系起来，提供用命名访问对象的方法。

目录服务：允许属性和对象联系，比如用户对象的email地址属性，（命名服务不提供），因此能利用目录服务访问对象属性或以属性为基础查找对象。

HTTP在TCP/IP的顶层，他是一种有web特性的网络协议。HTTP会话结构是一种简单的请求/响应序列；浏览器请求，服务器响应 。HTTP 响应可以 包含HTML，HTTP在响应内容（服务器返回的任何东西）之上添加头信息。浏览器利用头信息来帮助处理html页面。把hml内容看作粘贴在HTTP响应中的数据。HTTP请求中有几个方法，最常用的是POST和GET(区别)。HTTP响应中包含状态代码（如404),内容类型（也称为MIME类型，他告诉浏览器将会收到什么类型的数据以便处理，比如展示图片，提供html），响应的真实内容（html，图片等）。

We may wish to instantiate additional objects related to the Student object:
初始化与对象相关的一些额外对象：
public class Student() {
    // Every Student maintains a handle on his/her own individual Transcript object.
    private Transcript transcript;
    public Student() {
        // Create a new Transcript object for this new Student.
        transcript = new Transcript();
        // etc.
    }
}
读取数据库来初始化对象属性：
public class Student {
    // Attributes.
    String studentId;
    String name;
    double gpa;
    // etc.
    // Constructor.
    public Student(String id) {
        studentId = id;
        // Pseudocode.
        use studentId as a primary key to retrieve data from the Student table of a
        relational database;
        if (studentId found in Student table) {
           retrieve all data in the Student record;
            name = name retrieved from database;
            gpa = value retrieved from database;
        // etc.
        }
    }
// etc.
}

和其他已存在的对象交流：
public class Student {
    // Details omitted.
    // Constructor.
    public Student(String major) {
        // Alert the student's designated major department that a new student has
        // joined the university.
        // Pseudocode.
        majorDept.notify(about this student ...);
    // etc.
    }
    // etc.
}

好习惯：如果需要有参数的构造函数，最好同时显示声明一个无参构造函数。
容易出现的bug：如果给构造函数加上void编译会通过！不过会被当作方法而不是构造函数！
当有多个构造函数，而且都有共同的初始化内容时，就会出现很多重复的代码，比如构造一个新学生，我们会做：
1 通知登记办公室学生的存在
2 给学生创建学生成绩报告单
重复引起以后修改必须修改多处，如果使用this 会得到改善

public class Student {
 // Attribute details omitted.
 // Constructor #1.
 public Student() {
// Assign default values to selected attributes ... details omitted.
// Do the things common to all three constructors in this first
// constructor ...
// Pseudocode.
alert the registrar's office of this student's existence
// Create a transcript for this student.
transcript = new Transcript();
}

 // Constructor #2.
 public Student(String s) {
  // ... then, REUSE the code of the first constructor within the second!
  this();
  // Then, do whatever else extra is necessary for constructor #2.
  this.setSsn(s);
 }

 // Constructor #3.
 public Student(String s, String n, int i) {
  // ... and REUSE the code of the first constructor within the third!
  this();
  // Then, do whatever else extra is necessary for constructor #3.
  this.setSsn(s);
  this.setName(n);
  this.setAge(i);
 }
 // etc.
}