BlogJava-John Jiang

探烦HTTP/2: ��的状�?�?

John Jiang — Sat, 08 Oct 2016 13:17:00 GMT

探烦HTTP/2: ��的状�?/span>

探烦HTTP/2�p�d��的第四篇文章�Q�解��M��HTTP/2��的状态，以及状态之间的转化�?2016.10.09最后更�?

1. 概述
HTTP/2的流(Stream)是有状态的。当客户端或服务器端在��用某个流��d��送或接收特定�?Frame)或包含特定标�{?Flag)的��Ӟ��会引��h��的状态的转化�?a >HTTP 2协议定义的流状态，如下所�C�：

                         +--------+
                 send PP |        | recv PP
                ,--------|  idle  |--------.
               /         |        |         \
              v          +--------+          v
       +----------+          |           +----------+
       |          |          | send H /  |          |
,------| reserved |          | recv H    | reserved |------.
|      | (local)  |          |           | (remote) |      |
|      +----------+          v           +----------+      |
|          |             +--------+             |          |
|          |     recv ES |        | send ES     |          |
|   send H |     ,-------|  open  |-------.     | recv H   |
|          |    /        |        |        \    |          |
|          v   v         +--------+         v   v          |
|      +----------+          |           +----------+      |
|      |   half   |          |           |   half   |      |
|      |  closed  |          | send R /  |  closed  |      |
|      | (remote) |          | recv R    | (local)  |      |
|      +----------+          |           +----------+      |
|           |                |                 |           |
|           | send ES /      |       recv ES / |           |
|           | send R /       v        send R / |           |
|           | recv R     +--------+   recv R   |           |
| send R /  `----------->|        |<-----------'  send R / |
| recv R                 | closed |               recv R   |
`----------------------->|        |<----------------------'
                         +--------+

   send:   endpoint sends this frame
   recv:   endpoint receives this frame

   H:  HEADERS frame (with implied CONTINUATIONs)
   PP: PUSH_PROMISE frame (with implied CONTINUATIONs)
   ES: END_STREAM flag
   R:  RST_STREAM frame

    �ȝ��_��HTTP/2为流的整个生命周期定义了7�U�状态：idle�Q�reserved (local)�Q�reserved (remote)�Q�open�Q�half closed (local)�Q�half closed (remote)和closed。当一端发送或接收头部�?�׃��个HEADERS/PUSH_PROMISE帧和紧随它的零到多个CONTINUATION帧组成的集合)或RST_STREAM帧，或包含有END_STREAM标签的��(HEADERS和DATA)之后�Q�将改变��的状态�?/span>
    ��的状态基于各端自��q��视角。由于��的传输会有网�l��g�q�，在同一时刻�Q�不同端认�ؓ的流的状态可能是不同的。比如，当发送端使用一个处于idle状态的��发送一个不包含END_STREAM标签的HEADERS帧之后会立即认�ؓ该流处于open状态，但此时接收端��未得到该HEADERS帧，所以在那一时刻�Q�接收端依然认�ؓ该流的状态是idle�?/span>

2. idle
    所有的��在创徏之初都处于idle状态。处于idle状态的��，只允许被用于发送HEADERS帧，但可以被用于接收HEADERS和PRIORITY帧。在一端��用该状态的��发送或接收HEADERS帧之后，该端会认为此��的状态�{变�ؓopen。接收PRIORITY帧不会改变流的状态�?/span>
    一个idle状态的��可被另一个流通过发�?接收PUSH_PROMISE帧保留着�Q��其在��来被用于服务器端推送。被保留的流的状态则从idle变�ؓreserved (local/remote)�?/span>

3. open
    处于open状态的��可被用于发送�Q何类型的帧。��用该状态的��去发�?接收包含有END_STREAM标签的��(HEADERS和DATA)之后�Q�会使该��的状态变成half closed (local/remote)。��用open状态的��发送或接收RST_STREAM帧之后，则会使它的状态�{变�ؓclosed�?/span>

4. half closed (local/remote)
    状态half closed (local)与half closed (remote)中的local与remote的区别，完全是基于各端自��q��视角。对于同一个流的两端，如果一端认��个流的状态是half closed (local)�Q�那么另一端只能认��个流的状态是half closed (remote)�?/span>
    处于half closed (local)状态的��只能被用于发送WINDOW_UPDATE�Q�PRIORITY和RST_STREAM帧，但可以被用于接收��M��c�d��的��。相对应圎ͼ�处于half closed (remote)状态的��只能被用于接收WINDOW_UPDATE�Q�PRIORITY和RST_STREAM帧，但可以被用于发送�Q何类型的帧�?/span>

5. reserved (local/remote)
    与half closed (local/remote)状态相��|��reserved (local/remote)状态中的local与remote也是��Z��两端各自的视角。更具体的是�Q�服务器端发送PUSH_PROMISE��一个idle状态的��保留着以用于未来的推送，�q�视�q�个被保留的��的状态�ؓreserved (local)�Q�而客��L��则视�q�个��的状态�ؓreserved (remote)�?/span>
    服务器端使用reserved (local)状态的��向客户端发送HEADERS帧。该HEADERS帧就是服务器端推�?Server Push)中被推送的响应的头部。当发送了HEADERS帧之后，服务器端��视该流的状态�ؓhalf closed (remote)�?/span>
相应圎ͼ�客户端通过reserved (remote)状态的��接收到服务器端推送的响应的头部，然后会视该流的状态�ؓhalf closed (local)�?/span>
    扩展一下，服务器端推送中被保留的��的状态在变�ؓhalf closed(local/remote)之后才可能被用于接收/发送被推送的响应的体部，也就是DATA帧�?/span>

6. closed
    当一端��用一个流发送或接收到RST_STREAM帧，或通过状态�ؓhalf closed (local/remote)的流接收/发送包含有END_STREAM标签的��之后�Q�都会视�q�个��的状态�ؓclosed�?/span>
    closed状态预�C�着��的�l�结�Q�处于该状态的��将只能发送或接收PRIORITY帧。但有一个特例。即�Q�如果通过使用half closed (local/remote)状态的��去接收或发送包含有END_STREAM标签的��(HEADERS或DATA)�Q�以使该��的状态变为closed�Q�那么在此之后的较短旉��内，仍然可以接收WINDOW_UPDATE或RST_STREAM帧�?/span>

John Jiang 2016-10-08 21:17 发表评论

探烦HTTP/2: HPACK协议��q?�?

John Jiang — Sat, 24 Sep 2016 12:29:00 GMT

探烦HTTP/2: HPACK协议��q?/span>

探烦HTTP/2�p�d��的第一��文章已�l�介�l�了HTTP 2协议�Q�本文则��简�q�用于HTTP/2头部压羃�?a >HPACK协议�?2016.10.01最后更�?

1. 基本原理
    HPACK头部压羃的基本原理就是��用烦引表�?a >Huffman�~�码。在压羃(�~�码)与解�?解码)�q�程�Q�可��指定的头部字段(包含字段名与字段�?存储在烦引表中。烦引表中的每一个条目由索引(一个整�?�Q�字�D�名和字�D�值组成。对于存在烦引表中的头部字段�Q�在�~�码时可以仅使用索引作�ؓ该字�D늚�代表�Q�在解码旉��过该烦引从表中查找出对应的字段。对于其它的字符�Ԍ��则可以��用Huffman�~�码�q�行压羃�?br /> 1.1 索引�?/strong>
    索引表由静态表与动态表�l�成。静态表由HPACK协议预定义的61个常用的头部字段�l�成�Q�其中大部分字段的��gؓ�I�。静态表是只�ȝ��Q�其中的条目及其位置均不可更攏V��HPACK协议中的附录A列出了全部的静态表条目。动态表也由一�p�d��头部字段�l�成�Q�但其中的元素不固定�Q�在实际操作中可以插入新的条目，也允许删除已有的条目�?br />     HPACK协议要求静态表与动态表合�ƈ在同一个存储空间中�Q�其中静态表�|�于前部�Q�动态表紧随其后。那么在整个索引表空间中�Q�动态表的第一个条目的索引��是62。动态表的维护原则是先进先出(FIFO)。当向动态表中增加条目时�Q�将��L��从第62位插入，原有的条目将全部向右�U�d��一个位�|�。当从动态表中删除条目时�Q�将��L��从最后一位进行删除�?br />     虽说�Q�协议要求将静态表与动态表合�ƈ在一��P��但这只是逻辑上的要求。只要动态表的烦引是�?2开始，那么各个实现可以�Ҏ��自己的喜好自由地使用存储数据�l�构。比如，可以��静态表单独攑֜�一个不可变的数�l�中�Q�而动态表由另一个链表进行存储，�q�样可能会便于插入和删除条目。只不过�Q�这个链表中元素的下标与动态表中条目的索引之间相差62�?br />     (动�?索引表中的条目允讔R��复�?br /> 1.2 Huffman�~�码
    Huffman�~�码是一�U�用于无损数据压�~�的权�\径编码算法。在使用该算法时�Q�需要一张所有被�~�码字符的权�?出现频率)代码表。在对大量的HTTP头部��h��q�行�l�计之后�Q�得��Z��一份适用于HPACK的Huffman代码表，由协议中�?a >附录B列出�?br />
    必须注意的是�Q�HPACK协议�q�不要求该协议的实现一定要使用索引表，即便某个字段已经存在于烦引表中了。而且也不要求一定要对字�W�串实施Huffman压羃。也��是��_��理论上，在编码时可以不对头部字段�q�行��M��形式的压�~�，而只需��所有的字符转化成字节�Ş式�?br />
2. 基本数据�c�d��表示�?/span>
    HPACK协议使用的基本数据类型只有两�U�：整数�Q�字�W�串。该协议使用整数去表�C�烦引和字符串的长度。头部字�D�名和��g��出现的数字，只会被当作字�W�串�q�行处理�?br /> 2.1 整数表示�?/strong>
    HPACK在表�C�整数时�q�不是把它简单的转换成二�q�制形式。因为HPACK希望每一个整数的表示能够从某�?比特位字�?octet�Q�下文将其简写�ؓ"字节")中的��M��一个比特位开始，但��L��要在某个字节的最后一个比特位�l�束。比如表�C?27�Q�让它从字节的第一个比特位开始填充，肯定会在最后一个比特位�l�束�Q�如下图所�C�：

0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
+---+---+---+---+---+---+---+---+

如果�W�一个比特位被其它值占�?�??"代表)�Q�只能从�W�二个比特位开始填充呢�Q�结果依然只需要一个字节，如下所�C�：

0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| ? | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
+---+---+---+---+---+---+---+---+

但如果是从第三个比特位开始填充呢�Q�这时会发现一个字节已�l�不够了�Q�必��要�W�二个字节。但能否表示成如下�Ş式呢�Q?br />

0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| ? | ? | 1 | 1 | 1 | 1 | 1 | 1 |
+---+---+---+-------------------+
| 1 | ? | ? | ? | ? | ? | ? | ? |
+---+---+---+---+---+---+---+---+

�q�显然不�W�合HPACK协议的要求，因�ؓ它希望能够在某个字节的最后一个比特位�l�束�q�个表示。�ؓ辑ֈ��q�一目的�Q�HPACK协议设计��Z��一�U�如下图所�C�的表示法，

0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| ? | ? | 1 | 1   1   1   1   1 |
+---+---+---+-------------------+
| 1 |    Value-(2^N-1) LSB      |
+---+---------------------------+
               ...
+---+---------------------------+
| 0 |    Value-(2^N-1) MSB      |
+---+---------------------------+

�W�一个字节中能够被用来填充整数表�C�Z��的比特位�?上图中的�?)被称为prefix。下面是该表�C�法的Java语言实现�Q?br />
public void encodeInteger(int value, int prefix) {
    if (value >> prefix <= 0) {
        printBinary(value);
    } else {
        int number = (1 << prefix) - 1;
        printBinary(number);
        for (value -= number; value >= 128; value /= 128) {
            printBinary(value % 128 + 128);
        }
        printBinary(value);
    }
}

private void printBinary(int value) {
    System.out.println(String.format("%8s", Integer.toBinaryString(value)).replace(" ", "0"));
}
�Ҏ��上述��法可知�Q�当prefix�?�Ӟ��127的表�C�法如下图所�C�：

0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| ? | ? | 1 | 1 | 1 | 1 | 1 | 1 |
+---+---+---+-------------------+
| 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
+---+---+---+-------------------+

2.2 字符串表�C�法

0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| H |    String Length (7+)     |
+---+---------------------------+
| String Data (Length octets) |
+-------------------------------+

HPACK协议使用上图展示的表�C�法�Q�它�׃��部分�l�成�Q?br /> [1]Huffman标志�Q�表�C��字符串是否�ؓHuffman�~�码�Q�占用一个比特位�?br /> [2]字符串长度，一个��?.1节所�q�方法表�C�的整数�Q�其中prefix�?�?br /> [3]字符串倹{��若Huffman标志�?�Q�该值就是原始字�W�串的字节，否则该值是�l�Huffman�~�码�q�的数据。由于经Huffman�~�码�q�的数据�q�不��L��能在一个字节的最后一个比特位处结束，所以可能会使用EOS(end-of-string)�W�号�q�行填充�?br />
3. 头部字段表示�?/span>
    有了�W?节介�l�的基本数据�c�d��的表�C�法作�ؓ基础�Q�现在就可以阐述头部字段的表�C�法了。HPACK协议��字�D�表�C�法分成3�U�类型。在表示法开头有一个或若干个比特位用于表示�c�d��?br /> 3.1 已在索引表的头部字段
    �c�d��标识占用1个比特位�Q��gؓ1。烦引��用prefix�?的整数表�C�法。在解码�Ӟ��不会更新动态表�?br />

0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 1 |        Index (7+)         |
+---+---------------------------+

3.2 ��置入烦引表的头部字�D?/strong>
    �c�d��标识占用2个比特位�Q��gؓ01。在解码�Ӟ��会向动态表内插入新条目。这�U�类型又被分成两�U�情况：
[1]头部字段名已在烦引表中，字段名烦引��用prefix�?的整数表�C�法�Q�而字�D��g��用字�W�串表示法�?br />

0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 1 |      Index (6+)       |
+---+---+-----------------------+
| H |     Value Length (7+)     |
+---+---------------------------+
| Value String (Length octets) |
+-------------------------------+

[2]头部字段名不在烦引表中，字段名和字段值均使用字符串表�C�法�Q�而第一个字节的�?个比特位均��?填充�?br />

0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 1 |           0           |
+---+---+-----------------------+
| H |     Name Length (7+)      |
+---+---------------------------+
| Name String (Length octets) |
+---+---------------------------+
| H |     Value Length (7+)     |
+---+---------------------------+
| Value String (Length octets) |
+-------------------------------+

3.2 暂不�|�入索引表的头部字段
    �c�d��标识占用4个比特位�Q��gؓ0000。在解码�Ӟ��不向动态表内插入新条目。这�U�类型又被分成两�U�情况：
[1]头部字段名已在烦引表中，字段名烦引��用prefix�?的整数表�C�法�Q�而字�D��g��用字�W�串表示法�?br />

0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 0 | Index (4+)   |
+---+---+-----------------------+
| H |     Value Length (7+)     |
+---+---------------------------+
| Value String (Length octets) |
+-------------------------------+

[2]头部字段名不在烦引表中，字段名和字段值均使用字符串表�C�法�Q�而第一个字节的�?个比特位均��?填充�?br />

0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 0 |       0       |
+---+---+-----------------------+
| H |     Name Length (7+)      |
+---+---------------------------+
| Name String (Length octets) |
+---+---------------------------+
| H |     Value Length (7+)     |
+---+---------------------------+
| Value String (Length octets) |
+---+---------------------------+

3.3 �怸��|�入索引表的头部字段
    �c�d��标识占用4个比特位�Q��gؓ0001。在解码�Ӟ��不向动态表内插入新条目。这�U�类型又被分成两�U�情况：
[1]头部字段名已在烦引表中，字段名烦引��用prefix�?的整数表�C�法�Q�而字�D��g��用字�W�串表示法�?br />

0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 1 | Index (4+)   |
+---+---+-----------------------+
| H |     Value Length (7+)     |
+---+---------------------------+
| Value String (Length octets) |
+-------------------------------+

[2]头部字段名不在烦引表中，字段名和字段值均使用字符串表�C�法�Q�而第一个字节的�?个比特位均��?填充�?nbsp;

0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 0 | 0 | 1 |       0       |
+---+---+-----------------------+
| H |     Name Length (7+)      |
+---+---------------------------+
| Name String (Length octets) |
+---+---------------------------+
| H |     Value Length (7+)     |
+---+---------------------------+
| Value String (Length octets) |
+-------------------------------+

    可以发现�Q?.2节与3.3节中的表�C�法除了�c�d��标识不同之外�Q�其它的都完全相同。那么它们的区别是什么呢�Q�类�?000表示的字�D�在�l�过多次解码与编码时�Q�可能会被某个中介者置入烦引表中。而类�?001表示法强调了该字�D�|��论在��M��时候都不可�|�入索引表。类�?001可用于表�C�包含有敏感信息�Q�如密码�Q�的字段��|��以避免对�q�些��D��行压�~�时产生的风险�?br />
4. 动态表的管�?/span>
    动态表中的条目被认为是有尺寸的�Q�其计算公式为：字段名的字节长度+字段值的字节长度+32。字�D�名/值的长度是指它们的原始字节的长度�Q�而非�l�过Huffman�~�码后的字节的长度�?br />     动态表的尺寸就是其中所有条目的��寸之和。动态表的最大尺寸是有限的，可以通过下面的整数表�C�法来通知协议的现实去改变动态表的最大尺寸�?br />

0   1   2   3   4   5   6   7
+---+---+---+---+---+---+---+---+
| 0 | 0 | 1 |   Max size (5+)   |
+---+---------------------------+

    当插入新的条目或改变动态表的最大尺寸时�Q�可能导致已有的一个或多个条目被逐出�Q�甚��x��I�整个动态表。将动态表的最大尺寸设�|��ؓ0是合法的�Q�实际上�Q�这是一�U�常用的清空动态表的途径�?/div>

John Jiang 2016-09-24 20:29 发表评论

探烦HTTP/2: 初试HTTP/2(�?

John Jiang — Tue, 20 Sep 2016 08:42:00 GMT

探烦HTTP/2: 初试HTTP/2
目前支持HTTP/2的服务器端与客户端实现已有不��，探烦HTTP/2�p�d��的第二篇��分别以Jetty和curl作�ؓ服务器端和客��L��Q�描�q�C��HTTP/2��试环境的搭��E�。本文还��用这个测试环境去展示Jetty在实现HTTP/2时的一个局限和一个Bug�?2016.09.22最后更�?

1. HTTP/2的实�?/span>
    目前已经有众多的服务器端和客��L��实现了对HTTP/2的支持。在服务器端�Q�著名的Apache httpd�?.4.17版，Nginx�?.9.5版，开始支持HTTP/2。在客户端，��L��的浏览器�Q�如Chrome�Q�FireFox和IE�Q�的最新版均支持HTTP/2�Q�但它们都只支持�q�行在TLS上的HTTP/2(即h2)。��用Java语言实现的，则有Jetty和Netty�Q�它们都实现了服务器端和客户端。此处有一份HTTP/2实现的列表：https://github.com/http2/http2-spec/wiki/Implementations
    另外�Q�还有一些工��h��持对HTTP/2的分析与调试�Q�如curl和WireShark。这里也有一份此�c�d��L��列表�Q?a >https://github.com/http2/http2-spec/wiki/Tools

2. 服务器端
    作�ؓJava�E�序员，选用一�ƾ��用Java语言�~�写的开源HTTP/2服务器端实现��g��是很自然的结果。实际上�Q�在日后的研�I�中�Q�我们也需要查看服务器端的源代码。这对于深入地理解HTTP/2�Q��ƈ发现实现中可能的问题�Q�具有现实意义�?/span>
    本文选择Jetty的最新版�?.3.11作�ؓ服务器端。Jetty是一个成熟的Servlet容器�Q�这为开发Web应用�E�序提供了极大便利。而本文第1节中提到的Netty是一个传输层框架�Q�它专注于网�l�程序。可以��用Netty��d��发一个Servlet容器�Q�但�q�显然不如直接��用Jetty方便�?/span>
    安装和配�|�Jetty是一件很�Ҏ��的事情，具体�q�程如下所�C��?/span>
    假设此时已经下蝲�q�解压好了Jetty 9.3.11的压�~�文�Ӟ��目录名�ؓjetty-9.3.11。在其中创徏一个test-base子目录，作�ؓ��要创徏的Jetty Base的目录�?/span>
$ cd jetty-9.3.11
$ mkdir test-base
$ cd test-base
在创建Base�Ӟ��加入支持http�Q�https�Q�http2(h2)�Q�http2c(h2c)和deploy的模块�?/span>
$ java -jar ../start.jar --add-to-startd=http,https,http2,http2c,deploy

ALERT: There are enabled module(s) with licenses.
The following 1 module(s):
+ contains software not provided by the Eclipse Foundation!
+ contains software not covered by the Eclipse Public License!
+ has not been audited for compliance with its license

Module: alpn
  + ALPN is a hosted at github under the GPL v2 with ClassPath Exception.
  + ALPN replaces/modifies OpenJDK classes in the java.sun.security.ssl package.
  + http://github.com/jetty-project/jetty-alpn
  + http://openjdk.java.net/legal/gplv2+ce.html

Proceed (y/N)? y
INFO: server          initialised (transitively) in ${jetty.base}\start.d\server.ini
INFO: http            initialised in ${jetty.base}\start.d\http.ini
INFO: ssl             initialised (transitively) in ${jetty.base}\start.d\ssl.ini
INFO: alpn            initialised (transitively) in ${jetty.base}\start.d\alpn.ini
INFO: http2c          initialised in ${jetty.base}\start.d\http2c.ini
INFO: https           initialised in ${jetty.base}\start.d\https.ini
INFO: deploy          initialised in ${jetty.base}\start.d\deploy.ini
INFO: http2           initialised in ${jetty.base}\start.d\http2.ini
DOWNLOAD: http://central.maven.org/maven2/org/mortbay/jetty/alpn/alpn-boot/8.1.5.v20150921/alpn-boot-8.1.5.v20150921.jar to ${jetty.base}\lib\alpn\alpn-boot-8.1.5.v20150921.jar
DOWNLOAD: https://raw.githubusercontent.com/eclipse/jetty.project/master/jetty-server/src/test/config/etc/keystore?id=master to ${jetty.base}\etc\keystore
MKDIR: ${jetty.base}\webapps
INFO: Base directory was modified
    注意�Q�在上述�q�程中，会根据当前环境变量中使用的Java版本(此处�?.8.0_60)��M��载一个对应的TLS-ALPN实现jar文�g(此处为alpn-boot-8.1.5.v20150921.jar)�Q�该jar会用于对h2的支持。当启动Jetty�Ӟ��该jar会被Java的Bootstrap class loader加蝲到类路径中�?/span>
    创徏一个最��单的Web应用�Q��它在根目录下包含一个文本文件index�Q�内容�ؓ"HTTP/2 Test"�?/span>再包含一个简单的Servlet�Q�代码如下：
package test;

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class TestServlet extends HttpServlet {

    private static final long serialVersionUID = 5222793251610509039L;

    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.getWriter().println("Test");
    }

    @Override
    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }
}
web.xml主要是定义了一个Servlet�Q�具体内容如下：
xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
    metadata-complete="false" version="3.1">

    <welcome-file-list>
        <welcome-file>indexwelcome-file>
    welcome-file-list>

    <servlet>
        <servlet-name>testservlet-name>
        <servlet-class>test.TestServletservlet-class>
    servlet>
    <servlet-mapping>
        <servlet-name>testservlet-name>
        <url-pattern>/test/*url-pattern>
    servlet-mapping>
web-app>
该应用的部��v路径为jetty-9.3.11/test-base/webapps/test.war。在该WAR文�g所在的目录下，创徏一个test.xml�Q�其内容如下所�C�：
xml version="1.0"  encoding="ISO-8859-1"?>
DOCTYPE Configure PUBLIC "-//Jetty//Configure//EN" "http://www.eclipse.org/jetty/configure_9_0.dtd">

<Configure class="org.eclipse.jetty.webapp.WebAppContext">
  <Set name="contextPath">/Set>
  <Set name="war"><SystemProperty name="jetty.base" default="."/>/webapps/test.warSet>
Configure>
启动Jetty服务器，使用默认的HTTP和HTTPS端口�Q�分别�ؓ8080�?443�?/span>
$ java -jar ../start.jar
2016-09-15 21:15:51.190:INFO:oejs.Server:main: jetty-9.3.11.v20160721
2016-09-15 21:15:51.237:INFO:oejdp.ScanningAppProvider:main: Deployment monitor [file:///D:/http2/jetty/jetty-9.3.11/test-base/webapps/] at interval 1
2016-09-15 21:15:52.251:INFO:oejw.StandardDescriptorProcessor:main: NO JSP Support for /test.war, did not find org.eclipse.jetty.jsp.JettyJspServlet
2016-09-15 21:15:52.313:INFO:oejsh.ContextHandler:main: Started o.e.j.w.WebAppContext@4520ebad{/test.war,file:///D:/http2/jetty/jetty-9.3.11/test-base/webapps/test.war/,AVAILABLE}{D:\http2\jetty\jetty-9.3.11\test-base\webapps\test.war}
2016-09-15 21:15:52.391:INFO:oejw.StandardDescriptorProcessor:main: NO JSP Support for /, did not find org.eclipse.jetty.jsp.JettyJspServlet
2016-09-15 21:15:52.391:INFO:oejsh.ContextHandler:main: Started o.e.j.w.WebAppContext@711f39f9{/,file:///D:/http2/jetty/jetty-9.3.11/test-base/webapps/test.war/,AVAILABLE}{/test.war}
2016-09-15 21:15:52.532:INFO:oejs.AbstractConnector:main: Started ServerConnector@1b68ddbd{HTTP/1.1,[http/1.1, h2c, h2c-17, h2c-16, h2c-15, h2c-14]}{0.0.0.0:8080}
2016-09-15 21:15:52.735:INFO:oejus.SslContextFactory:main: x509=X509@e320068(jetty,h=[jetty.eclipse.org],w=[]) for SslContextFactory@1f57539(file:///D:/http2/jetty/jetty-9.3.11/test-base/etc/keystore,file:///D:/http2/jetty/jetty-9.3.11/test-base/etc/keystore)
2016-09-15 21:15:52.735:INFO:oejus.SslContextFactory:main: x509=X509@76f2b07d(mykey,h=[],w=[]) for SslContextFactory@1f57539(file:///D:/http2/jetty/jetty-9.3.11/test-base/etc/keystore,file:///D:/http2/jetty/jetty-9.3.11/test-base/etc/keystore)
2016-09-15 21:15:53.234:INFO:oejs.AbstractConnector:main: Started ServerConnector@4b168fa9{SSL,[ssl, alpn, h2, h2-17, h2-16, h2-15, h2-14, http/1.1]}{0.0.0.0:8443}
2016-09-15 21:15:53.249:INFO:oejs.Server:main: Started @3940ms
    �Ҏ��上述日志可知�Q�Jetty启用了Web应用test.war�Q�还启动了两个ServerConnector�Q�一个支持h2c�Q�另一个支持h2。值得注意的是�Q�这两个ServerConnector�q�分别支持h2c-17, h2c-16, h2c-15, h2c-14和h2-17, h2-16, h2-15, h2-14。这是因为，HTTP/2在正式发布之前，先后发布�?8个草案，其编号�ؓ00-17。所以，�q�里的h2c-XX和h2-XX指的��是�W�XX可��案�?/span>

3. 客户�?/span>
    其实最方便的客��L��是��览器了。只要��用的FireFox或Chrome版本不是太老，肯定都已�l�支持了HTTP/2�Q�而且�q�一功能是默认打开的。也��是��_��当��用FireFox去访问前面所部��v的Web应用�Ӟ��是在��用HTTP/2�Q�但你不会感觉到�q�种变化。��用FireFox提供的Developer Tools中的Network工具查看服务器端的响应，会发现HTTP版本为HTTP/2.0。但此处希望�q�个客户端能够提供更��Z��富的与服务器端进行交互的功能�Q�那么浏览器��ƈ不合适了�?br />    Jetty也实��C��支持HTTP/2的客��L��Q�但�q�个客户端是一个API�Q�需要编写程序去讉K��HTTP/2服务器端。而且�Q�目前该API的设计抽象层�ơ较低，需要应用程序员对HTTP/2协议�Q�比如各�U��Q�有较深入的了解。这对于初涉HTTP/2的开发者来��_��昄��很不合适。本文选择使用C语言�~�写的一个工��P��其实也是HTTP/2的客��L��实现之一�Q�curl�?/span>
    curl在支持HTTP/2�Ӟ��实际上是使用了nghttp2的C库，所以需要先安装nghttp2。另外，��Z��让curl支持h2�Q�就必须要有TLS-ALPN的支持。那么，一般地�q�需要安装OpenSSL 1.0.2+�?/span>
    �|�络上关于在Linux下安装支持HTTP/2的curl的资源有很多�Q�过�E��ƈ不难�Q�但有点儿繁�Q�要安装的依赖比较多�Q�本文就不赘�q�C��。如果是使用Windows�Q�笔者比较推荐通过Cygwin来安装和使用curl。在Windows中安装Cygwin非常��单，在Cygwin中执行各�U�命令时�Q�感觉上��如同在使用Linux�Q�尽��它�q�不是一个虚拟机。通过Cygwin安装curl�Q�它会自动地安装所需的各�U�依赖程序和库�?/span>
    在笔者的机器上，通过查看curl的版本会出现如下信息�Q?/span>
curl 7.50.2 (x86_64-unknown-cygwin) libcurl/7.50.2 OpenSSL/1.0.2h zlib/1.2.8 libidn/1.29 libpsl/0.14.0 (+libidn/1.29) libssh2/1.7.0 nghttp2/1.14.0
Protocols: dict file ftp ftps gopher http https imap imaps ldap ldaps pop3 pop3s rtsp scp sftp smb smbs smtp smtps telnet tftp
Features: Debug IDN IPv6 Largefile GSS-API Kerberos SPNEGO NTLM NTLM_WB SSL libz TLS-SRP HTTP2 UnixSockets Metalink PSL
�׃��可知�Q�笔者��用的curl版本�?.50.2�Q�nghttp2版本�?.14.0�Q�而OpenSSL版本�?.0.2h�?/span>

4. �W�一�ơ尝�?/span>
    在第一�ơ尝试中�Q�只需要简单地讉K��W?节中部��v的Web应用中的静态文本文件index�Q�以感受下h2c�Q�完整命令如下：
$ curl -v --http2 http://localhost:8080/index
在输��Z��包含有如下的内容�Q?/span>
...
> GET /index HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.50.2
> Accept: */*
> Connection: Upgrade, HTTP2-Settings
> Upgrade: h2c
> HTTP2-Settings: AAMAAABkAAQAAP__
>
...
< HTTP/1.1 101 Switching Protocols
* Received 101
* Using HTTP2, server supports multi-use
* Connection state changed (HTTP/2 confirmed)
...
< HTTP/2 200
< server: Jetty(9.3.11.v20160721)
< last-modified: Wed, 14 Sep 2016 12:52:32 GMT
< content-length: 11
< accept-ranges: bytes
<
...
HTTP/2 Test
">"是客��L��发送的��h��Q?<"是服务器端发送的响应�Q��?*"是curl对当前过�E�的说明�?/span>�l�合本系�?a href="http://www.dentisthealthcenter.com/jiangshachina/archive/2016/09/19/431811.html">�W�一��文�?/a>中所��q�的HTTP 2协议�Q�可以有以下的基本理解�?/span>
[1]客户端发起了一个HTTP/1.1的请求，其中携带有Upgrade头部�Q�要求服务器端升�U�到HTTP/2(h2c)�?/span>
> GET /index HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.50.2
> Accept: */*
> Connection: Upgrade, HTTP2-Settings
> Upgrade: h2c
> HTTP2-Settings: AAMAAABkAAQAAP__
>
[2]服务器端同意升��Q�返回响�?101 Switching Protocols"�Q�然后客��L��收到�?01响应�Q�HTTP/2�q�接�q�行��认�?/span>
< HTTP/1.1 101 Switching Protocols
* Received 101
* Using HTTP2, server supports multi-use
* Connection state changed (HTTP/2 confirmed)
[3]服务器端响应最�l�结果。状态行中出现的HTTP版本为HTTP/2�Q�状态代码�ؓ200�Q�且后面没有跟着"OK"。最后输��Z��index文�g的内�?HTTP/2 Test"�?/span>
< HTTP/2 200
< server: Jetty(9.3.11.v20160721)
< last-modified: Wed, 14 Sep 2016 12:52:32 GMT
< content-length: 11
< accept-ranges: bytes
<
...
HTTP/2 Test

5. 一个局�?/span>
    �q�次�Q�在发�v的请求中包含体部�Q�命令如下：
$ curl -v --http2 -d "body" http://localhost:8080/index
在输��Z��包含有如下的内容�Q?/span>
...
> POST /index HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.50.2
> Accept: */*
> Connection: Upgrade, HTTP2-Settings
> Upgrade: h2c
> HTTP2-Settings: AAMAAABkAAQAAP__
> Content-Length: 4
> Content-Type: application/x-www-form-urlencoded
>
...
< HTTP/1.1 200 OK
< Last-Modified: Wed, 14 Sep 2016 12:52:32 GMT
< Accept-Ranges: bytes
< Content-Length: 11
...
HTTP/2 Test
    和第4节中的输��行比较，会发现缺��了"101 Switching Protocols"那一�D�，而且最�l�响应状态行中出现的HTTP版本是HTTP/1.1。这��p��明服务器端不同意升��Q�后面��l��用HTTP/1.1。刚刚部�|�的Jetty未做��M��改变怎么会突然不支持HTTP/2了呢�Q�或者这是curl的问题？其实�Q?/span>�q�是因�ؓJetty服务器端在实现h2c时不支持��h��中包含体部。另外，Apache httpd也有同样的问题。如果是使用h2�Q�则没有�q�个限制。这背后的原因超��Z��本文的范��_��不作表述�?/span>

6. 一个Bug
    在这�ơ尝试中�Q�测试一下两端对100-continue的支持。如果请求中使用了头�?Expect: 100-continue"�Q�那么正常地该请求要有体部。但�׃��在第5节中介绍的问题，此时不能再��用h2c�Q�而只能��用h2。另外，�q�次不访问静态文�Ӟ��而是讉K��Servlet(此处�?test)。完整命令如下：
$ curl -vk --http2 -H "Expect: 100-continue" -d "body" https://localhost:8443/test
在输出的最后出��C��如下信息�Q?/span>
curl: (92) HTTP/2 stream 1 was not closed cleanly: CANCEL (err 8)
�q�其实是Jetty的一�?a >Bug�Q�正在开发中�?.3.12已经修复了它�?/span>

7. ��结
    HTTP/2依然��是新潮的技术，对各家的实现�Q�无论是服务器端�Q�客��L��Q�还是分析工��P��都要持有一份怀疑态度。这些实现和工具都是�E�序�Q�都有可能存在bug。而且协议对许多细节没有作��定，各家都会发挥自己的想像力。比如，Apache httpd和Jetty在实现服务器端推送时�Q�其方式��׃��相同�?br />    在开发自��q��HTTP/2实现或应用的时候，需要同时��用已有的不同服务器端和客��L��去部�|�多套测试环境进行对比分析�?br />

John Jiang 2016-09-20 16:42 发表评论

探烦HTTP/2: HTTP 2协议��q?�?

John Jiang — Mon, 19 Sep 2016 03:36:00 GMT

探烦HTTP/2: HTTP/2协议��q?/span>
HTTP/2的协议包含着两个RFC�Q�Hypertext Transfer Protocol Version 2 (RFC7540)�Q�即HTTP/2�Q�HPACK: Header Compression for HTTP/2 (RFC7541)�Q�即HPACK。RFC7540描述了HTTP/2的语义，RFC7541则描�q�C��用于HTTP/2的头部压�~�的格式。本文只涉及HTTP/2协议�Q�本�p�d��的后�l�文章将会涉及HPACK协议�?2016.10.13最后更�?

1. HTTP/2要解决的问题
     HTTP/1.0只允许在一个TCP�q�接中出��C��个请求。后来的HTTP/1.1虽然引入了请求流水线�Q�以允许在一个连接中发送多个请求，但这只是部分地解决了��h��q�发的问题。服务器端在�q�回响应�Ӟ��q�是必须要按照它接收到的��h��的顺序进行返回。如果排在前面的响应要消耗较长的旉��Q�那依然会对后面的响应的造成��d��Q�亦即线头阻�?Head-of-line blocking)。所以，客户端必��要使用多条�q�接��d��起多个的��h��以实现�ƈ发，�q�进而减��g�q�。更大的�q�发会增大服务器的负载，也会占用更大的网�l�带宽。另外，头部通常会包含有大量的信息，如cookie�Q�而这也会增加�|�络传输的开销�?/span>
     HTTP/2允许在同一个TCP�q�接中交错地出现多个��h��与响应，亦即多工(Multiplex)。同�Ӟ��它��用了一个高效的�~�码�Ҏ��对头部进行压�~�。HTTP/2�q�允许对��h��q�行优先�U�排序，以便让更为重要的��h��得以更快的完成，�q�会�q�一步提高性能。HTTP/2�q�改变了服务器端只能被动地向客户端返回响应的定式�Q�允许服务器端主动地向客��L��推送数据，�q�就可以减少客户端发赯��求的数量�?/span>
     ��M��Q�HTTP/2主要是解��x��能问题�?/span>

2. 发�vHTTP/2
     HTTP/2会��用与HTTP/1相同的URI scheme�Q�即http和https。而且实现HTTP/2的服务器端也不会使用不同的端口去分别支持HTTP/1和HTTP/2。这��h��利于�q�x��C��HTTP/1升��到HTTP/2。毕竟目前已部��v的绝大部分网�l�服务都只支持HTTP/1�Q�当未来它们升��到HTTP/2�Ӟ��如果换用了不同URI scheme或端口，那么肯定会对客户端��生极大的影响。但是HTTP/2协议��行在http和https上的HTTP/2分别定义了两个不同的标识�W�：h2c和h2。h2c中的"c"指的是cleartext�Q�即明文。本文后面会使用h2c指代�q�行在http2�?直接使用TCP)的HTTP/2�Q�而用h2指代�q�行在https�?使用TLS)的HTTP/2�?/span>
     那么�Q�支持HTTP/2的客��L��如何知道它所�q�接的服务器端是否也支持HTTP/2呢？
     对于h2c�Q�支持HTTP/2的客��L��可以在发��L��h��中��用HTTP/1.1的Upgrade头部��d��试要求服务器升��到HTTP/2。该��h��的格式如下：
GET / HTTP/1.1
Host: server.example.com
Connection: Upgrade, HTTP2-Settings
Upgrade: h2c
HTTP2-Settings:
HTTP2-Settings是一个经由BASE64�~�码�q�的字符�Ԍ��其原始内�Ҏ��客户端将要发送的SETTINGS帧的载荷�Q�即一些配�|�参数�?/span>
     如果服务器端支持HTTP/2�Q�它��响�?101 Switching Protocols"�Q�表�C�可以进行升�U�。该响应的格式如下：
HTTP/1.1 101 Switching Protocols
Connection: Upgrade
Upgrade: h2c
     如果服务器端不支持HTTP/2�Q�则会忽略Upgrade��h��头部�Q�后�l�依然��用HTTP/1.1�?/span>
     对于h2�Q�会使用到协议Transport Layer Security (TLS) Application-Layer Protocol Negotiation Extension (RFC7301)�Q�即TLS-ALPN。该协议允许客户端和服务器端��׃��用何�U�版本的HTTP�q�行协商。如果TLS-ALPN在现实中�q�行良好的话�Q�也许某天还会��用该�Ҏ��d��商��用别的协议�?/span>
     当客��L��与服务器端都同意使用HTTP/2�Ӟ��双方都需要各自发��Z��个连接序�a�(Connection Preface)以进行最后的��认�?/span>
     客户端在接收到服务器端的"101 Switching Protocols"响应(针对h2c)或TLS�q�接的第一个应用数据字�?针对h2)之后会立卛_��接序�a�。该序言的开头是"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"(其十六进制�Ş式�ؓ"0x505249202a20485454502f322e300d0a0d0a534d0d0a0d0a")⁽¹⁾�Q�后面必��d��跟一个SETTINGS帧，哪怕这个��是空的�?/span>
     服务器端的连接序�a�则由一个SETTINGS帧构成，该��必须是服务器端在HTTP/2�q�接中发送的�W�一个��。这个SETTINGS帧可以�ؓ�I�，也可以包含一些希望客��L��如何与自��p��行通信的必要配�|�信息�?/span>

3. �?Frame)
     HTTP/2消息使用二进制格�?实际�~�码时��用十六进制书�?�Q�相比于文本格式�Q�这样可以提高消息处理的效率。HTTP/2消息的最��单元�ؓ帧，它由头部与蝲�?Payload)�l�成。每个��的长度必��L��一个或多个8比特位字�?octet�Q�下文将其简写�ؓ"字节")�?/span>
     帧头部依�ơ包含有如下�?个字�D�：
     长度(Length)�Q�该字段占用24个比特位�Q�代表��载荷的长度。该长度是一�?4位的无符��h��数�?/span>
     �c�d��(Type)�Q�该字段占用8个比特位�Q�代表��的类型�?/span>
     标志(Flags)�Q�该字段占用8个比特位�Q�代表��所定义的一个或多个标志。�ƈ不是所有的帧都定义了标志�?/span>
     保留�?R)�Q�该字段占用1个比特位�Q�其语义��未被定义。在��d��帧时�Q�该位需要被忽略�Q�但在发送��Ӟ��该位需要保持�ؓ0(0x0)�?/span>
     ��标识符(Stream Identifier)�Q�该字段占用31个比特位�Q�代表该帧所在流的标识符�?/span>
     在头部之后，紧接着的就是蝲荗��蝲��L��l�构与内容完全由帧的�c�d��军_��Q�它的长度也是不定的�?br />
     HTTP/2定义了如�?0�U�不同类型的帧�?/span>
     DATA�Q�用于携带一�l�长度不定的字节。一个或多个DATA可作��求或响应的蝲荗��?/span>
     HEADERS�Q�用于开启一个流�Q��ƈ可携带一个头部块片断。头部块指由一个HEADERS/PUSH_PROMISE帧和紧随它的零到多个CONTINUATION帧组成的集合�Q�因为只有它们才可能携带头部信息。这个集合可被分割成一个或一�l�字节，�q�样的字节被�U�Cؓ头部块片断。头部块中各个特定类型的帧必��ȝ��紧相邻，不能出现其它�c�d��的��?/span>
     PRIORITY�Q�用于指定发送端��的流优先�U��?/span>
     RST_STREAM�Q�用于立即终止流。当希望取消一个流或发生错误时�Q�就可发送RST_STREAM帧�?/span>
     SETTINGS�Q�用于携带可以媄响两端之间通信方式的配�|�参数。SETTINGS帧定义了一个ACK标志�Q�用于指�C��帧所讄��的参数是否已被接收端��L��。当收到一个SETTINGS且其中的ACK标志�?�Ӟ��接收端必��d��可能快的应用其中已被更新的参数�?/span>
     PUSH_PROMISE�Q�用于向接收端通知发送端��要创徏的流。当接收端接收到该��Ӟ��新的��尚未被发送端创徏�Q�但发送端承诺会创��。该帧用于实现HTTP/2的重要特�?服务器端推�?Server Push)"�?/span>
     PING�Q�用于测量发送端与接收端之间的最��往�q�时间。这与��用众所周知的ping命��o的目的相��|��是�ؓ了测试某个空闲的�q�接是否�q�可用�?/span>
     GOAWAY�Q�用于发起对�q�接的关闭，或触发严重的错误条�g。该帧允�怸�端，在完成对之前已创建的��的处理的同�Ӟ��优雅地停止接收新的流。一端在创徏新的��，另一端在发送GOAWAY�Q�这两者之间天然存在着竞争关系。�ؓ了就对这�U�情况，发送端在发送GOAWAY时会让它携带�?该发送端所知晓�?接收端最后创建的��的标识�W�，当该GOAWAY被发送之后，发送端��会忽视由接收端创徏的�Q何一个标识符比该标识�W�大的流�?/span>
     WINDOW_UPDATE�Q�用于流量控制。该帧的载荷�׃��个单比特保留位和一�?1比特位的无符��h��数组成。该整数向该帧的接收端指�C�Z��其向当前��量控制�H�口所能增加传输量的倹{�?/span>
     CONTINUATION�Q�用于��l�发送头部块片断。只要同一个流中前面的帧是HEADERS�Q�PUSH_PROMISE或CONTINUATION�Q��ƈ且该帧没有设�|�END_HEADERS标志�Q�那么可无限量地发送CONTINUATION帧�?/span>
     部分帧，DATA�Q�HEADERS和PUSH_PROMISE�Q�的载荷中可能包含填�?Padding)。填白在业务上没有实际的用处�Q�它的出现是��Z��安全目的。比如，可以用它来扰乱实际数据的长度�Q�以减轻特定的HTTP��d��?br />
     发送端发送的帧的最大长度要��重接收端设定的SETTINGS_MAX_FRAME_SIZE的倹{��但该值的范围要介�?^14�?^24-1个字节之间�?/span>

4. ��?Stream)
     ��是用于在客��L��与服务器端之间进行��传送的通道�Q�同一个TCP�q�接中可以同时有多个��，如下图所�C�，

┌────────┐          Connection           ┌────────┐
│        │ ============================= │        │
│        │    --------------------- <-- Stream    │
│        │    ┌─────┐┌─────────┐┌─┐      │        │
│        │    └─────┘└─────────┘└─┘ <-- Frame     │
│        │    ---------------------      │        │
│ Client │                               │ Server │
│        │    ----------                 │        │
│        │    ┌──┐┌────┐                 │        │
│        │    └──┘└────┘                 │        │
│        │    ----------                 │        │
│        │ ============================= │        │
└────────┘                               └────────┘

服务器端和客��L��可以交错地向同一个连接中的不同流中传送��。可以把一个流看作HTTP/1中的一个连接。客��L��与服务器端在同一个流中的交互依然遵��@发送请�?�{�待响应模式。两端都可以创徏新的��，�׃�n�Ҏ��创徏的流�Q�也可以关闭�Ҏ��创徏的流。��在流中的��序是有意义的，接收端会以接收到的顺序去处理帧�?br />      每个��都有一个标识符�Q�是一�?1比特位的无符合整数。在同一个连接中�Q�流标识�W�是唯一的。由客户端创建的��的标识�W��ؓ奇数�Q�由服务器创建的��的标识�W��ؓ偶数。但标识�W��ؓ0的流可看作连接，用于�q�接控制信息�Q�创建新的流时不可��用该标识�W�。同一个连接中的�Q何一个流的标识符都不可重用，即便�q�个��已被关闭了。对于长旉��没有中断的连接，可能会出现标识符不够用的情况�Q�那时就必须强制创徏一个新的连接�?br />      HTTP/2协议为流的生命周期定义了7�U�状�?sup>(2)�Q�idle�Q�reserved(local)�Q�reserved(remote)�Q�open�Q�half closed(local)�Q�half closed(remote)和closed。当一端接收或发送头部块�?帧DATA和HEADERS�?标志RST_STREAM后可使流的状态发生�{变�?/span>
     使用��来实现多工��׃��引�v对TCP�q�接使用的竞争，�q�会造成��的��d��。基于��WINDOW_UPDATE的流量控制方案可以确保相同连接中的流�怺�之间不会产生破坏性干扰。流量控制可以作用于两个层面�Q�即单个��或整个�q�接。只有��DATA需要遵守流量控�Ӟ��所有其它的帧所有消耗的�I�间均不会占用流量控制窗口。HTTP/2协议只是定义了WINDOW_UPDATE帧的�l�构和语义，协议的实现可以选择��M��适用自己的流量控制算法�?/span>
     ��可以有优先�U�。客��L��在创��Z��个新的流�Ӟ��可在HEADERS中指定优先��权重。在后箋��M��旉��Q�通过PRIORITY可以改变��的优先�U�权重。在�q�发能力有限的情况下�Q�高权重��的帧会被优先传送。权重的值必��M��?�?56之间�Q�默认权重�ؓ16�?/span>��与��之间还可以有依赖关�p�，�q�种关系会组成一��依赖关�p�L��。一个流能够指定自己成�ؓ另一个流的子��。这一�q�程�Q�可以是非排他的�Q�也可以是排他的。非排他性依赖，是指一个流在将自己变成另一个流的子��的�q�程中，允许另一个流�q�有别的子流�Q�即允许有自��q��兄弟��存在。排他性依赖，指在前述�q�程中，不允许另一个流�q�有别的子流。如果另一个流已经有子��了�Q�那么该��会把所有潜在的兄弟��先变成自己的子��，然后再��自己成�ؓ另一个流的唯一子流。其实，排他性依赖的作用��是��Z��能够打破已有的关�p�L��Q�在既成的父子节点中插入新的节点。否则，只能为已有节�Ҏ��加子节点�Q�那么关�p�L��不可能�q�行重构。所有的��在被创建时�Q�默认成为标识符�?x0的流的子��。在"服务器端推�?中生成的"推�?��将自动地成为生成该推送流的流的子��，光��认权重也�?6�?/span>

5. 消息交换
5.1 ��h��/响应交换
     HTTP/2沿袭了HTTP/1的语义，��x��有的��h��与响应语义均得到了保留，��管传递这些语义的语法已经改变了�?/span>
     一个HTTP/2消息由如下几个部分组成：
     [1]仅对于响应消息，可以包含一个携带有1xx响应头部的头部块。该头部块由一个HEADERS帧和紧随它的零到多个CONTINUATION帧组成�?/span>
     [2]一个头部块。该头部块由一个HEADERS帧和紧随它的零到多个CONTINUATION帧组成�?/span>
     [3]零到多个携带有体�?Body)消息的DATA帧。HTTP/1中��用的"分块(chunked)"体部��不适用于HTTP/2。因��Z��个体部可由多个DATA帧组成，所以HTTP/2的体部天然就是可分块的�?/span>
     [4]一个可能存在的包含着��N��消息的头部块。该头部块由一个HEADERS帧和紧随它的零到多个CONTINUATION帧组成�?br />
     HTTP/2仍然沿用HTTP/1中的头部字段�Q�但字段名称中的字母必须全部为小写。另外，�q�将HTTP/1消息开始行(��h��中的��h��?/a>与响应中�?a >状态行)中的消息�Q�分解成了若�q�伪头部字段�Q�此�c�d��D�均以冒�?:)开头�?/span>
     HTTP/1��h��行格式�ؓ"method request-target HTTP-version"�Q�对应的HTTP/2伪头部字�D�|��:method=method�?path=request-target�Q�但HTTP-version无对应字�D�，默认为HTTP/2�?/span>
     HTTP/1状态行格式�?HTTP-version status-code reason-phrase"�Q�对应的HTTP/2伪头部字�D�|��:status=status-code。但HTTP-version无对应字�D�，默认为HTTP/2�Q�reason-phrase也无对应字段�Q�因为可以通过状态代码查扑ֈ�其对应的reason-phrase。HTTP/2协议是在��量减少冗余消息�?/span>
     HTTP/2协议�q��ؓ��h��头部定义了另外两个伪字段�Q?/span>
     :scheme�Q�URI中的scheme部分。它可以不仅仅是http或https�Q�因为有时候可能会与非HTTP服务�q�行交互�?/span>
     :authority�Q�URI中的授权部分。即�Q�scheme://user:password@host:port/path?query#fragment中的"user:password@host:port"�?/span>
     HTTP/2协议8.1.3节中�l�出一些简单示例，展示了如何将HTTP/1消息对应到HTTP/2消息�?/span>
5.2 服务器端推�?/span>
     HTTP/2的服务器端推送是传统的请�?响应模式的一�U�特�D��Ş式。服务器端在收到客户端的��h��(主请�?之后�Q��ؓ了主动向客户端推送更多的内容�Q�会自动地生成若�q�新的请�?推送请�?。服务器向客��L��发送的响应中，不仅包含对主��h��的响�?��d��?�Q�还包含�Ҏ��送请求的响应(推送响�?�?/span>
     客户端可以通过发送包含有SETTINGS_MAX_CONCURRENT_STREAMS参数的SETTINGS帧去��用服务器端推送，也可以通过发送RST_STREAM帧去取消已经发�v的服务器端推送，但不能发送包含有END_STREAM标志的��?br />
(1)"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"中的"PRI"�?SM"合�v来就�?RRISM(��镜)"。呵呵，HTTPbis工作�l�这是想表达什么意思呢 ;-)
(2)本系列的后箋文章解读了流的状态�?br />

John Jiang 2016-09-19 11:36 发表评论

Play OpenJDK: 允许你的包名�?java."开�?�?

John Jiang — Sun, 01 Nov 2015 12:06:00 GMT

Play OpenJDK: 允许你的包名�?java."开�?/span>

本文是Play OpenJDK的第二篇�Q�介�l�了如何�H�破JDK不允许自定义的包名以"java."开头这一限制。这一技巧对于基于已有的JDK向java.*中添加新�c�还是有所帮助的�?2015.11.02最后更�?

无论是经验丰富的Java�E�序员，�q�是Java的初学者，��M��有一些�h或有意或无意地创��Z��个包名�ؓ"java"的类。但��Z��安全斚w��的考虑�Q�JDK不允许应用程序类的包名以"java"开��_��即不允许java�Q�java.foo�q�样的包名。但javax�Q�javaex�q�样的包名是允许的�?br />
1. 例子
比如�Q�以OpenJDK 8为基��Q�臆造这样一个例子。笔者想向OpenJDK贡献一个同步的HashMap�Q�即�c�SynchronizedHashMap�Q�而该�cȝ��包名��׃ؓjava.util。SynchronizedHashMap是HashMap的同步代理，�׃��q�两个类是在同一包内�Q�SynchronizedHashMap不仅可以讉K��HashMap的public�Ҏ��与变量，�q�可以访问HashMap的protected和default�Ҏ��与变量。SynchronizedHashMap看�v来可能像下面�q�样�Q?br />
package java.util;

public class SynchronizedHashMap<K, V> {

    private HashMap<K, V> hashMap = null;

    public SynchronizedHashMap(HashMap<K, V> hashMap) {
        this.hashMap = hashMap;
    }

    public SynchronizedHashMap() {
        this(new HashMap<>());
    }

    public synchronized V put(K key, V value) {
        return hashMap.put(key, value);
    }

    public synchronized V get(K key) {
        return hashMap.get(key);
    }

    public synchronized V remove(K key) {
        return hashMap.remove(key);
    }

    public synchronized int size() {
        return hashMap.size; // 直接调用HashMap.size变量�Q�而非HashMap.size()�Ҏ��
    }
}

2. ClassLoader的限�?/span>
使用javac�ȝ��译源文�gSynchronizedHashMap.java�q�没有问题，但在使用�~�译后的SynchronizedHashMap.class�Ӟ��JDK的ClassLoader则会拒绝加蝲java.util.SynchronizedHashMap�?br />设想有如下的应用�E�序�Q?br />
import java.util.SynchronizedHashMap;

public class SyncMapTest {

    public static void main(String[] args) {
        SynchronizedHashMap<String, String> syncMap = new SynchronizedHashMap<>();
        syncMap.put("Key", "Value");
        System.out.println(syncMap.get("Key"));
    }
}
使用java命��o去运行该应用�Ӟ��会报如下错误�Q?br />
Exception in thread "main" java.lang.SecurityException: Prohibited package name: java.util
    at java.lang.ClassLoader.preDefineClass(ClassLoader.java:659)
    at java.lang.ClassLoader.defineClass(ClassLoader.java:758)
    at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
    at java.net.URLClassLoader.defineClass(URLClassLoader.java:467)
    at java.net.URLClassLoader.access$100(URLClassLoader.java:73)
    at java.net.URLClassLoader$1.run(URLClassLoader.java:368)
    at java.net.URLClassLoader$1.run(URLClassLoader.java:362)
    at java.security.AccessController.doPrivileged(Native Method)
    at java.net.URLClassLoader.findClass(URLClassLoader.java:361)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:331)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
    at SyncMapTest.main(SyncMapTest.java:6)
�Ҏ��ClassLoader.preDefineClass()的源代码如下�Q?br />
private ProtectionDomain preDefineClass(String name,
        ProtectionDomain pd)
{
    if (!checkName(name))
        throw new NoClassDefFoundError("IllegalName: " + name);

    if ((name != null) && name.startsWith("java.")) {
        throw new SecurityException
            ("Prohibited package name: " +
            name.substring(0, name.lastIndexOf('.')));
    }
    if (pd == null) {
        pd = defaultDomain;
        }

    if (name != null) checkCerts(name, pd.getCodeSource());

    return pd;
}
很清楚地�Q�该�Ҏ��会先��查待加蝲的类全名(卛_��?�c�d��)是否�?java."开��_��如是�Q�则抛出SecurityException。那么可以尝试修改该�Ҏ��的源代码�Q�以�H�破�q�一限制�?br />从JDK中的src.zip中拿出java/lang/ClassLoader.java文�g�Q�修改其中的preDefineClass�Ҏ��以去除相关限制。重新编译ClassLoader.java�Q�将生成的ClassLoader.class�Q�ClassLoader$1.class�Q�ClassLoader$2.class�Q�ClassLoader$3.class�Q�ClassLoader$NativeLibrary.class�Q�ClassLoader$ParallelLoaders.class和SystemClassLoaderAction.class��L��换JDK/jre/lib/rt.jar中对应的�c�R�?br />再次�q�行SyncMapTest�Q�却仍然会抛出相同的SecurityException�Q�如下所�C�：
Exception in thread "main" java.lang.SecurityException: Prohibited package name: java.util
    at java.lang.ClassLoader.defineClass1(Native Method)
    at java.lang.ClassLoader.defineClass(ClassLoader.java:760)
    at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
    at java.net.URLClassLoader.defineClass(URLClassLoader.java:467)
    at java.net.URLClassLoader.access$100(URLClassLoader.java:73)
    at java.net.URLClassLoader$1.run(URLClassLoader.java:368)
    at java.net.URLClassLoader$1.run(URLClassLoader.java:362)
    at java.security.AccessController.doPrivileged(Native Method)
    at java.net.URLClassLoader.findClass(URLClassLoader.java:361)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:331)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
    at SyncMapTest.main(SyncMapTest.java:6)
此时是由�Ҏ��ClassLoader.defineClass1()抛出的SecurityException。但�q�是一个native�Ҏ��Q�那么仅通过修改Java代码是无法解册��个问题的(JDK真是层层��N��?。原来在Hotspot的C++源文件hotspot/src/share/vm/classfile/systemDictionary.cpp中有如下语句�Q?br />
const char* pkg = "java/";
if (!HAS_PENDING_EXCEPTION &&
    !class_loader.is_null() &&
    parsed_name != NULL &&
    !strncmp((const char*)parsed_name->bytes(), pkg, strlen(pkg))) {
  // It is illegal to define classes in the "java." package from
  // JVM_DefineClass or jni_DefineClass unless you're the bootclassloader
  ResourceMark rm(THREAD);
  char* name = parsed_name->as_C_string();
  char* index = strrchr(name, '/');
  *index = '\0'; // chop to just the package name
  while ((index = strchr(name, '/')) != NULL) {
    *index = '.'; // replace '/' with '.' in package name
  }
  const char* fmt = "Prohibited package name: %s";
  size_t len = strlen(fmt) + strlen(name);
  char* message = NEW_RESOURCE_ARRAY(char, len);
  jio_snprintf(message, len, fmt, name);
  Exceptions::_throw_msg(THREAD_AND_LOCATION,
    vmSymbols::java_lang_SecurityException(), message);
}
修改该文件以去除掉相关限�Ӟ��q�按照本�p�d��?a href="http://www.dentisthealthcenter.com/jiangshachina/archive/2015/10/30/427994.html">�W�一��文�?/a>中介�l�的�Ҏ��去重新构��Z��个OpenJDK。那么，�q�个新的JDK��不会再对包名有��M��限制了�?br />
3. 覆盖Java核心API�Q?/strong>
开发者们在��用主��IDE时会发现�Q�如果工�E�有多个jar文�g或源文�g目录中包含相同的�c�，�q�些IDE会根据用��h��定的优先�U�顺序来加蝲�q�些�c�R��比如，在Eclipse中，右键点击某个Java工程-->属�?->Java Build Path-->Order and Export�Q�在�q�里调整各个�c�d��或源文�g目录的位�|�，卛_��指定加蝲�cȝ��优先�U��?br />当开发者在使用某个开源类�?jar文�g)�Ӟ��惛_��其中某个�c�进行修改，那么��可以将该类的源代码复制出来�Q��ƈ在Java工程中创��Z��个同名类�Q�然后指定Eclipse优先加息自己创徏的类。即�Q�在�~�译时与�q�行时用自己创徏的类去覆盖类库中的同名类。那么，是否可以如法炮制去覆盖Java核心API中的�c�d��Q?br />考虑去覆盖类java.util.HashMap�Q�只是简单在它的put()�Ҏ��d��一条打印语。那么就需要将src.zip中的java/util/HashMap.java复制出来�Q��ƈ在当前Java工程中创��Z��个同名类java.util.HashMap�Q��ƈ修改put()�Ҏ��Q�如下所�C�：
package java.util;

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
    .
    public V put(K key, V value) {
        System.out.printf("put - key=%s, value=%s%n", key, value);
        return putVal(hash(key), key, value, false, true);
    }

}
此时�Q�在Eclipse环境中，SynchronizedHashMap使用的java.util.HashMap被认为是上述新创建的HashMap�c�R��那么运行应用程序SyncMapTest后的期望输出应该如下所�C�：
put - key=Key, value=Value
Value
但运行SyncMapTest后的实际输出却�ؓ如下�Q?br />
Value
看�v来，新创建的java.util.HashMap�q�没有被使用上。这是�ؓ什么呢�Q�能�?惛_��"到的原因�q�是�c�d��载器。关于Java�c�d��载器的讨��Z��本文的范��_��而且关于该主题的文章已是汗牛充栋�Q�但本文仍会��q�其要点�?br />Java�c�d��载器�׃��至上分�ؓ三个层次�Q�引导类加蝲�?Bootstrap Class Loader)�Q�扩展类加蝲�?Extension Class Loader)和应用程序类加蝲�?Application Class Loader)。其中引导类加蝲器用于加载rt.jar�q�样的核心类库。�ƈ且引导类加蝲器�ؓ扩展�c�d��载器的父加蝲器，而扩展类加蝲器又为应用程序类加蝲器的父加载器。同时JVM在加载类时实行委托模式。即�Q�当前类加蝲器在加蝲�c�L��Q�会首先委托自己的父加蝲器去�q�行加蝲。如果父加蝲器已�l�加载了某个�c�，那么子加载器��不会再�ơ加载�?br />�׃��可知�Q�当应用�E�序试图加蝲java.util.Map�Ӟ��它会首先逐��向上委托父加载器��d��载该�c�，直到引导�c�d��载器加蝲到rt.jar中的java.util.HashMap。由于该�c�d��l�被加蝲了，我们自己创徏的java.util.HashMap��׃��会被重复加蝲�?br />使用java命��o�q�行SyncMapTest�E�序时加上VM参数-verbose:class�Q�会在窗口中打印出�Ş式如下的语句�Q?br />
[Opened /home/ubuntu/jdk1.8.0_custom/jre/lib/rt.jar]
[Loaded java.lang.Object from /home/ubuntu/jdk1.8.0_custom/jre/lib/rt.jar]

[Loaded java.util.HashMap from /home/ubuntu/jdk1.8.0_custom/jre/lib/rt.jar]
[Loaded java.util.HashMap$Node from /home/ubuntu/jdk1.8.0_custom/jre/lib/rt.jar]

[Loaded java.util.SynchronizedHashMap from file:/home/ubuntu/projects/test/classes/]
Value
[Loaded java.lang.Shutdown from /home/ubuntu/jdk1.8.0_custom/jre/lib/rt.jar]
[Loaded java.lang.Shutdown$Lock from /home/ubuntu/jdk1.8.0_custom/jre/lib/rt.jar]
从中可以看出�Q�类java.util.HashMap��实是从rt.jar中加载到的。但理论上，可以通过自定义类加蝲器去打破委托模式�Q�然而这��是另一个话题了�?/div>

John Jiang 2015-11-01 20:06 发表评论

Play OpenJDK: 构徏你自��q��JDK(�?

John Jiang — Fri, 30 Oct 2015 15:17:00 GMT

Play OpenJDK: 构徏你自��q��JDK

计划使Play OpenJDK成�ؓ一�l�介�l�如何��用�ƈ参与OpenJDK��目的系列文章。本文是该系列的�W�一��文章，它基于OpenJDK 8的源代码介绍了构��Z��个属于自��q��JDK�Ҏ��?2015.10.30最后更�?

1. OpenJDK
曄��的Sun Microsystems. Inc�Q�也��是Java语言的发明者，��它的JDK代码贡献出来�Q�成立了一个开源项目，�?a >OpenJDK�?br />    同时�Q�它也是一个社区。相关的公司�Q�组�l�和个�h在这个社��Z��协作开发OpenJDK。社区根据不同的领域或项目提供了一�p�d��?a >邮�g列表�Q�利益相��x��或对其感兴趣的个人都可以订阅�q�些邮�g列表去进行关注和讨论。例如，Java核心API的邮件列表是core-libs-dev@openjdk.java.net�Q�关于java.lang�Q�java.util�{�核心API的新�Ҏ��都会在�q�里�q�行讨论�Q��ƈ对其最�l�的实现代码�q�行审查。�Q何将要进入OpenJDK版本库的源代码，无论是��品代�?卻I��要随JDK发布的程�?�Q�还是测试代码，都需要在�C�֌�中进行公开的代码审查�?br />    选择一个自己感兴趣的领域或��目�Q�加入它的邮件列表，长期跟踪它的发展�Q�看着专家们的讨论、争论推动JDK的演�q�，学习开发者们的API设计与代码实玎ͼ�...�Q�这些对自己的成镉K��是极有帮助的。也许，�q�能看到一些有��的八卦;-)

2. 准备工作
在几�U�主��操作系�l�，Linux(如Ubuntu和Fedora)�Q�Windows(7�?)�Q�MacOS(Lion和Moutain Lion)�Q�中都可以构建OpenJDK�Q�具体的�l�节可以参见官方的一��文�?/a>�?br />    本文选择使用Ubuntu 14.04。坦白地��_��选择使用Ubuntu�Q�实是因为在Linux环境中构建OpenJDK非常��单。若在Windows中进行构建，则需要安装Visual Studio C++�~�译器。MacOS�Q�嗯�Q�我没有MBP。可能更多�h�q�x��是��用Windows�Q�但安装一个Linux也不�ȝ��。先安装免费的VM工具 VirtaulBox�Q�再��M��载Ubuntu�?a >ISO文�g�Q�然后��用VirtualBox��d��装Ubuntu。VirtualBox��单易用，�|�上的相兌��料也非常的多�?br />    OpenJDK的源文�g版本库基�?a >Mercurial(hg)�Q�它是一个与Git�怼�的分布式版本控制工具。在Ubuntu中安装Mercurial只需要执行命�?br />
$ sudo apt-get install mercurial
    OpenJDK中各��目的源代码版本库的路径均在http://hg.openjdk.java.net/之下�Q�在�q�里可以扑ֈ�6�Q?�Q?�Q?和Jigsaw的源代码。其中JDK 8的最新开发版本库路径为http://hg.openjdk.java.net/jdk8u/jdk8u-dev/�?br />    另外�Q�构建OpenJDK旉��要一个启动JDK�Q�本文选择构徏OpenJDK 8�Q�那么启动JDK的版本应不低�?�?br />
3. 下蝲源代�?/span>
克隆版本库，
$ hg clone http://hg.openjdk.java.net/jdk8u/jdk8u-dev/ jdk8-src
requesting all changes
adding changesets
adding manifests
adding file changes
added 1570 changesets with 1958 changes to 141 files
updating to branch default
85 files updated, 0 files merged, 0 files removed, 0 files unresolved
�q�入源代码目�?br />
$ cd jdk8-src/
OpenJDK的源代码版本库实际上包含多个独立的子版本库，需要执行如下脚本去分别下蝲各个子版本库的源代码�Q?br />
$ sh get_source.sh
# Repositories:  corba jaxp jaxws langtools jdk hotspot nashorn
                corba:   hg clone http://hg.openjdk.java.net/jdk8u/jdk8u-dev/corba corba
                 jaxp:   hg clone http://hg.openjdk.java.net/jdk8u/jdk8u-dev/jaxp jaxp
                corba:   requesting all changes
                 jaxp:   requesting all changes

4. 构徏
调用configure�q�行预构建，其中的参�?-with-boot-jdk用于指定启动JDK的�\径。如果启动JDK的java命��o已存在于PATH环境变量中，该参数可以忽略�?br />
$ sh configure --with-boot-jdk=/path/to/boot/jdk
该过�E�会��构建环境是否符合要求，如有问题�Q�它会给出提�C�。比如，
configure: error: Could not find X11 libraries. You might be able to fix this by running 'sudo apt-get install libX11-dev libxext-dev libxrender-dev libxtst-dev libxt-dev'.
此时�Ҏ��提示安装所需要的库即可。再重新执行上述configure命��o�Q�可能还会提�C�缺��其它的库，那么再次�Ҏ��提示�q�行安装。如此反复，只到预构建成功完成�?br />最后就是进行构建，直接执行如下命��o�Q?br />
$ make all
在此�q�程中可以会遇到一些警告，不必理会�Q�耐心�{�待...完成后，会出现如下的汇��M��息，
----- Build times -------
Start 2015-10-30 22:11:10
End   2015-10-30 22:52:54
00:01:01 corba
00:01:08 demos
00:06:49 docs
00:19:37 hotspot
00:01:47 images
00:00:35 jaxp
00:00:49 jaxws
00:08:23 jdk
00:01:09 langtools
00:00:25 nashorn
00:41:44 TOTAL
-------------------------
Finished building OpenJDK for target 'all'
在当前�\径下会生成一个build目录�Q�构建好的JDK��在那里面。新JDK的具体�\径类��g��build/linux-x86_64-normal-server-release/images/jdk。可以执行如下命令去��试�q�个JDK�Q?br />
$ build/linux-x86_64-normal-server-release/images/jdk/bin/java -version
openjdk version "1.8.0-internal"
OpenJDK Runtime Environment (build 1.8.0-internal-ubuntu_2015_10_30_22_07-b00)
OpenJDK 64-Bit Server VM (build 25.66-b00, mixed mode)

John Jiang 2015-10-30 23:17 发表评论

利用Java SE 8��处理数据II(�?

John Jiang — Fri, 15 Aug 2014 11:57:00 GMT

利用Java SE 8��处理数�?/strong>
-- �l�合Stream API的高�U�操作去表示富数据处理查�?/div>
本文�?/span>Java Magazine 201405/06刊中的一��文章，也是文章�p�d��"利用Java SE 8��处理数�?中的�W�二��，它基于flatMap()和collect()介绍了Java��的高��用法(2014.08.15最后更�?

在本�p�d��的第一��文章中�Q�你看到了Java��让你能够��用与数据库操作相似的�Ҏ��d��理集合。作��Z��个复习，清单1的例子展�C�Z��如何使用Stream API��L��得大交易的金额之和。我们组��Z��一个管道，它由中间操作(filter和map)与最�l�操�?reduce)构成�Q�图1形象地展�C�它�?/span>
清单1
int sumExpensive =
        transactions.stream()
        .filter(t -> t.getValue() > 1000)
        .map(Transaction::getValue)
        .reduce(0, Integer::sum);
�?

然而在�p�d��的第一部分中，�q�没有研�I�这两个�Ҏ��Q?/span>
flatMap�Q�这是一个中间操作，它允许将一�?map"和一�?flatten"操作�l�合在一�?/span>
collect�Q�这是一个最�l�操作，它依据不同的方式�Q�将��中的元素归集�ؓ一个结果�?/span>
�q�两个方法对于表达更为复杂的查询是十分有用的。例如，你可以将flatMap和collect�l�合��h��Q�生成代表一个文字流中每个字母出现的�ơ数的Map对象�Q�如清单2所�C�。如果第一�ơ看到这�D�代码觉得很惊奇�Ӟ��但请不要担心。本文的目的��是要解释�ƈ探究�q�两个方法更多的�l�节�?/span>
清单2
import static java.util.function.Function.identity;
import static java.util.stream.Collectors.*;

Stream<String> words = Stream.of("Java", "Magazine", "is", "the", "best");
Map<String, Long> letterToCount =
        words.map(w -> w.split(""))
        .flatMap(Arrays::stream)
        .collect(groupingBy(identity(), counting()));
清单2中的代码��会生成如清�?�C�的�l�果。棒极了�Q�不是吗�Q�让我们开始探�I�flatMap和collect�Ҏ��是如何工作的�?/span>
清单3
[a:4, b:1, e:3, g:1, h:1, i:2, ..]

flatMap�Ҏ��
假设你想扑և�文�g中所有独一唯二的字。你会怎么做呢�Q?/span>
你可能认��很简单；我们可以Files.lines()�Q�在前面的文章中已见�q�了�q�个�Ҏ��Q�因为它会返回一个包含文件中所有行的流。然后我们就可以使用map�Ҏ��每一行拆分成字，最后再使用distinct�Ҏ��去除重复的字。第一�ơ尝试得到的代码可能如清�?所�C��?/span>
清单4
Files.lines(Paths.get("stuff.txt"))
        .map(line -> line.split("\\s+")) // Stream
        .distinct() // Stream
        .forEach(System.out::println);
不幸的是�Q�这�D늨�序�ƈ不十分正��。如果运行它�Q�会得到令�h生疑的结果，与下面的输出有些�c�M��Q?/span>
[Ljava.lang.String;@7cca494b
[Ljava.lang.String;@7ba4f24f
...
我们的第一�ơ尝试确实打印出了代表几个流对象的字�W�串。那发生了什么呢�Q�该�Ҏ��的问题是�Q�传�l�map�Ҏ��的Lambda表达式返回的是文件中每一行的String数组(String[])。而我们真正想要的是一个表�C�文字的��的Stream对象�?/span>
�q�运的是�Q�对于该问题有一个解��x��案，��是使用flatMap�Ҏ��。让我们一步一步地看看如何得到正确的解��x��法�?/span>
首先�Q�我们需要字的流�Q�而不是数�l�的��。有一个名为Arrays.stream()的方法，它将使用一个数�l�作为参敎ͼ��q�生成一个流。请看清�?中的例子�?/span>
清单5
String[] arrayOfWords = {"Java", "Magazine"};
Stream<String> streamOfwords = Arrays.stream(arrayOfWords);
让我们在前面的流��道中��用该�Ҏ��Q�看看会发生什�?见清�?)。这个方案依然行不通。那是因为我们最�l�得到的是一�l�流的流(准确地说�Q�就是Stream>)。确切地是，我们首先��每一行�{换�ؓ一个字的数�l�，然后使用�Ҏ��Arrays.stream()��每一个数�l��{换成一个流�?/span>
清单6
Files.lines(Paths.get("stuff.txt"))
       .map(line -> line.split("\\s+")) // Stream
       .map(Arrays::stream) // Stream>
       .distinct() // Stream>
       .forEach(System.out::println);
我们使用flatMap()�Ҏ��去解册��个问题，如清�?所�C�。��用flatMap()�Ҏ��能够用流中的内容�Q�而不是流��L��换每一个生成的数组。换�a�之，通过map(Arrays::stream)�Ҏ��生成的全部独立的��被合�ƈ�?扁��^�?��Z��个流。图2形象地展�C�Z��使用flatMap()�Ҏ��的效果�?/span>
清单7
Files.lines(Paths.get("stuff.txt"))
       .map(line -> line.split("\\s+")) // Stream
       .flatMap(Arrays::stream) // Stream
       .distinct() // Stream
       .forEach(System.out::println);
本质上，flatMap让你可以使用其它��去替换另一个流中的每个元素�Q�然后再��所有生成的��连合�ƈ��Z��个流�?/span>
��h��意，flatMap()是一个通用的模式，在��用Optaional或CompletableFuture�Ӟ��你还会看到它�?/span>

collect�Ҏ��
现在让我们看看collect�Ҏ��的更多细节。在本系列的�W�一��文章中你所看到的方法，要么�q�回另一个流(卻I��q�些�Ҏ��是中间操�?�Q�要么返回一个��|��例如一个boolean�Q�一个int�Q�或一个Optional对象(卻I��q�些�Ҏ��是最�l�操�?�?/span>
collect��是一个最�l�方法，但它有点儿不同，因�ؓ你可以用它将一个Stream对象转�ؓ一个List对象。例如，��Z��得到一个包含有所有高金额交易ID的列表，你可以��用像清单8那样的代码�?/span>
清单8
import static java.util.stream.Collectors.*;

List<Integer> expensiveTransactionsIds =
        transactions.stream()
        .filter(t -> t.getValue() > 1000)
        .map(Transaction::getId)
        .collect(toList());
传递给collect�Ҏ��的参数就是一个类型�ؓjava.util.stream.Collector的对象。这个Collector对象是干什么的�Q�本质上看，它描�q�C��如何按照需要去攉��中的元素，再将它们生成��Z��个最�l�结果。之前用到的工厂�Ҏ��Collector.toList()会返回一个Collector对象�Q�它描述了如何将一个Stream对象归集��Z��个List对象。而且�Q�Collctors内徏有有许多�怼�的方法。例如，使用toSet()�Ҏ��可以��一个Stream对象转化��Z��个Set对象�Q�它会删除所有重复的元素。清�?中的代码展示了如何生成一个仅仅包含高金额交易所在城市的Set对象�?注意�Q�在后面的例子中�Q�我们假设Collectors�c�M��的工厂方法都已通过语句import static java.util.stream.Collectors.*被静态引入了)
清单9
Set<String> cities =
        transactions.stream()
        .filter(t -> t.getValue() > 1000)
        .map(Transaction::getCity)
        .collect(toSet());
注意�Q�无法保证会�q�回何种�c�d��的Set对象。但是，通过使用toCollection()�Q�你可以�q�行更多的控制。例如，若你惛_��C��个HashSet�Q�可以传一个构造器�l�toCollection�Ҏ��(见清�?0)�?/span>
清单10
Set<String> cities =
        transactions.stream()
        .filter(t -> t.getValue() > 1000)
        .map(Transaction::getCity)
        .collect(toCollection(HashSet::new));
然而，�q��ƈ不是你能用collect和Collector所做的全部事情。实际上�Q�这只是你能用它们所做的事情中的极小部分。下面是一些你所能表辄��查询的例子：
��交易按货币分类�Q��ƈ计算每种货币的交易金额之�?�q�回一个Map对象)
��交易划分成两组�Q�高金额交易和非高金额交�?�q�回一个Map>对象)
创徏多层分组�Q�例如先按交易发生的城市分组�Q�再�q�一步按它们是否为高金额交易�q�行分组(�q�回一个Map>>)
兴奋吗？很好。让我们看看�Q�你是如何��用Stream API和Collector来表达上�q�查询的。我们首先从一个简单的例子开始，�q�个例子要对�q�个��进�?�ȝ��"�Q�计��它的��^均��|��最大值和最��倹{��然后我们再看看如何表达��单的分组�Q�最后，再看看如何将Collector�l�合��h��d��建更为强大的查询�Q�例如多层分�l��?/span>
�ȝ��。让我们用一些简单的例子来热�w�一下。在之前的文章中�Q�你已经看到如何使用reduce�Ҏ��去计��流中元素的数量�Q�最��|��最大值和�q�_��|��以及如何使用基本数据�c�d��元素的流。有一些预定义的Collector�c�M��能让你完成那些功能。例如，可以使用counting()�Ҏ��去计��元素的数量�Q�如清单11所�C��?/span>
清单11
long howManyTransactions = transactions.stream().collect(counting());
你可以��用summingDouble()�Q�summingInt()和summingLong()分别�Ҏ��中元素类型�ؓDouble�Q�Int或Long的属性求和。在清单12中，我们计算��Z��所有交易的金额之和�?/span>
清单12
int totalValue = transactions.stream().collect(summingInt(Transaction::getValue));
�c�M��的，使用averagingDouble()�Q�averagingInt()和averagingLong()去计��^均��|��如清�?3所�C��?/span>
清单13
double average = transactions.stream().collect(averagingInt(Transaction::getValue));
另外�Q��用maxBy()和minBy()�Ҏ��Q�可以计��出��中值最大和最��的元素。但�q�里有一个问题：你需要�ؓ��中元素定义一个顺序，以能够对它们�q�行比较。这��是��Z��么maxBy�Q�）和minBy()�Ҏ��使用使用一个Comparator对象作�ؓ参数�Q�图3表明了这一炏V�?/span>
�?

在清�?4的例子中�Q�我们��用了静态方法comparing()�Q�它��传入的函数作�ؓ参数�Q�从中生成一个Comparator对象。该函数用于从流的元素中解析出用于进行比较的关键字。在�q�个例子中，通过使用交易金额作�ؓ比较的关键字�Q�我们找��C��那笔最高金额的交易�?/span>
清单14
Optional<Transaction> highestTransaction =
        transactions.stream()
        .collect(maxBy(comparing(Transaction::getValue)));
�q�有一个reducing()�Ҏ��Q�由它��生的Collector对象会把��中的所有元素归集在一��P��对它们重复的应用同一个操作，直到产生�l�果。该�Ҏ��与之前看�q�的reduce()�Ҏ��在原理上一��L��。例如，清单15展示了��用了��Z��reducing()�Ҏ��的另一�U�方式去计算所有交易的金额之和�?/span>
清单15
int totalValue = transactions.stream().collect(reducing(0, Transaction::getValue, Integer::sum));
reducing()�Ҏ��使用三个参数�Q?/span>
初始�?如果��ؓ�I�，则返回它)�Q�此处，该��gؓ0�?/span>
应用于流中每个元素的函数对象�Q�此处，该函��C��解析出每�W�交易的金额�?/span>
��两个由解析函数生成的金额合�q�在一��L��Ҏ��Q�此处，我们只是把金额加��h��?/span>
你可能会��_��"�{�等�Q��用其它的��方法，如reduce()�Q�max()和min()�Q�我已经可以做到�q�些了。那么，你�ؓ什么还要给我看�q�些�Ҏ��呢？"后面�Q�你��会看到我们��Collector�l�合��h��L��建更为复杂的查询(例如�Q�对加法�q�_��数进行分�l?�Q�所以，�q�也能更易于理解�q�些内徏的Collector�?/span>
分组。这是一个普通的数据库查询操作，它��用属性去数据�q�行分组。例如，你也许想按币�U�对一�l�交易进行分�l�。若你��用如清单16所�C�的代码�Q�通过昑ּ�的遍历去表达�q�个查询�Q�那会是很痛苦的�?/span>
清单16
Map<Currency, List<Transaction>> transactionsByCurrencies = new HashMap< >();
for(Transaction transaction : transactions) {
    Currency currency = transaction.getCurrency();
    List<Transaction> transactionsForCurrency =
    transactionsByCurrencies.get(currency);

    if (transactionsForCurrency == null) {
        transactionsForCurrency = new ArrayList<>();
        transactionsByCurrencies.put(currency, transactionsForCurrency);
    }
    transactionsForCurrency.add(transaction);
}
你首先需要创��Z��个Map对象�Q�它��收集所有的交易记录。然后，你需要遍历所有的交易记录�Q��ƈ解析出每�W�交易的币种。在��交易记录��用一个值插入Map中之前，需要先��查一下，�q�个List是否已经创徏�q�了�Q�等�{��?/span>
真是令�h汗颜啊，因�ؓ我们惌��?按币�U�对交易�q�行分组"。�ؓ什么不得不涉及�q�么多代码呢�Q�有好消息：有一个称为groupingBy()的Collector�Q�它允许我们以简�z�的方式来表达这个例子。我们可以��用清�?7中的例子来表达这个相同的查询�Q�现在代码的阅读更接�q�问题语句了�?/span>
清单17
Map<Currency, List<Transaction>> transactionsByCurrencies =
        transactions.stream().collect(groupingBy(Transaction::getCurrency));
工厂�Ҏ��groupingBy()使用一个函数对象作为参敎ͼ�该函��C��解析出用于分�c�M��易记录的关键字。我们称��个函��Cؓ分类函数。在此处�Q��ؓ了按币种对交易进行分�l�，我们传入一个方法引用，Transaction::getCurrency。图4演示了这个分�l�操作�?/span>
�?

分割。有一个称为partitioningBy()的工厂方法，它可被视��Z��U�特�D�的groupingBy()�Ҏ��。它使用一个谓语作为参�?该参数返回一个boolean�?�Q�然后根据元素是否满��个谓语对它们�q�行分组。换�a�之，它将�l�成��的交易分割成了�l�构Map>。例如，如若你想��交易分割成两组--低廉的和昂贵�?-你就可以像清�?8那样��M��用partitioningBy()产生的Collector。此例中的Lambda表达式，t->t.getValue() > 1000�Q�就是一个将交易分成低廉和昂�늚�谓语�?/span>
清单18
Map<Boolean, List<Transaction>> partitionedTransactions =
        transactions.stream().collect(partitioningBy(t -> t.getValue() > 1000));
�l�合Collector。如果你熟悉SQL�Q�你应该知道可以��GROUP BY与函数COUNT()和SUM()一块儿使用�Q�以按币�U�和交易金额之和�q�行分组。那么，使用Stream API是否也可以实现相似的功能呢？当然可以。确切地��_��有一个重载的groupingBy()�Ҏ��Q�它使用另一个Collector作�ؓ�W�二个参数。这个额外的Collector对象用于定义在��用由groupingBy()产生的Collector时如何汇集所有与关键字相关的元素�?/span>
好吧�Q�这听�v来有些抽象，那么让我们看一个简单的例子。我们想��Z��每个城市的交易金额之和生成一个城市的Map对象(见清�?9)。在此处�Q�我们告诉groupingBy()�Ҏ��使用getCity()�Ҏ��作�ؓ分类�Ҏ��。那么，得到的Map�l�果的Key��׃ؓ城市。正常地�Q�我们期望对Map中每个键所对应的��|��即List对象�Q��用groupingBy()�Ҏ��?/span>
清单19
Map<String, Integer> cityToSum =
        transactions.stream().collect(groupingBy(Transaction::getCity,
        summingInt(Transaction::getValue)));
然后�Q�我们却是传入了另一个Collector对象�Q�它由summingInt()�Ҏ��产生�Q�该�Ҏ��会将所有与特定城市相关的交易记录的金额加�v来。结果，我们得到了一个Map对象�Q�它��每个城市与它们对应的所有交易的金额之和�q�行了映��。酷�Q�不是吗�Q�想惌��个：基本的groupingBy(Transaction:getCity)�Ҏ��其实��只是groupingBy(Transaction:getCity, toList())的简写�?/span>
让我们看看另一个例子。如果你想生成这样一个Map�Q�它�Ҏ��个城市与它的最大金额的交易记录�q�行映射�Q�那要怎么做呢�Q�你可能已经猜到了，我们可以重用前面�q�的由maxBy()�Ҏ��产生的Collector�Q�如清单20所�C��?/span>
清单20
Map<String, Optional<Transaction>> cityToHighestTransaction =
        transactions.stream().collect(groupingBy(Transaction::getCity,
        maxBy(comparing(Transaction::getValue))));
你已�l�看到Stream API很善于表达，我们正在构徏的一些十分有��的查询都可以写的简�z�些。你�q�能惌��出回��C��前去遍历地处理一个集合吗�Q�让我们看一个更为复杂的例子�Q�以�l�束�q�篇文章。你已看到groupingBy()�Ҏ��可以��一个Collector对象作�ؓ参数�Q�再�Ҏ��q�一步的分类规则��L��集流中的元素。因为groupingBy()�Ҏ��本��n得到的也是一个Collector对象�Q�那么通过传入另一个由groupingBy()�Ҏ��得到的Collector对象�Q�该Collector定义了第二��的分�c�规范，我们��p��够创建多层次分组�?/span>
在清�?1的代码中�Q�先按城市对交易记录�q�行分组�Q�再�q�一步对每个城市中的交易记录按币�U�进行分�l�，以得到每个城市中每个币种的所有交易记录的�q�_��金额。图5��Ş象地展示了这�U�机制�?/span>
清单21
Map<String, Map<Currency, Double>> cityByCurrencyToAverage =
        transactions.stream().collect(groupingBy(Transaction::getCity,
        groupingBy(Transaction::getCurrency,
        averagingInt(Transaction::getValue))));
�?

创徏你自��q��Collector。到目前为止�Q�我们展�C�的全部Collector都实��C��接口java.util.stream.Collector。这��意味着�Q�你可以实现自己的Collector�Q�以"定制"归一操作。但是对于这个主题，再写一��文章可能更合适一些，所以我们不会在本文中讨��个问题�?/span>

�l�论
在本文中�Q�我们探讨了Stream API中的两个高��Q�flatMap和collect。它们是可以加到你的兵器库中的工��P��可以用来表述丰富的数据处理查询�?/span>
特别圎ͼ�你也已经看到了，collect()�Ҏ��可被用于归纳�Q�分�l�和分割操作。另外，�q�些操作�q�可能被�l�合在一��P��L��建更��Z��富的查询�Q�例�?生��一个两层Map对象�Q�它代表每个城市中每个币�U�的�q�_��交易金额"�?/span>
然而，本文也没有查�I�到所有的内徏Collector实现。请你去看看Collectors�c�，�q�试试其它的Collector实现�Q�例如由mapping()�Q�joining()和collectingAndThen()�Q�也�怽�会发现它们也很有用�?/span>

John Jiang 2014-08-15 19:57 发表评论

利用Java SE 8��处理数�?I)(�?

John Jiang — Sun, 27 Jul 2014 12:54:00 GMT

利用Java SE 8��处理数�?/span>
-- 使用Java��操作去表达复杂的数据查�?/span>

本文�?a >Java Magazine 201403/04刊中的一��文章，也是文章�p�d��"利用Java SE 8��处理数�?中的�W�一��，它概�q�C��Java��的基本原理与基本应用，是一��很好的Java Streams API的入门文章�?2014.07.27最后更�?

    没有集合对象�Q�你会怎么��P��几乎每个Java应用都会创徏�q�处理集合。它们是许多�~�程��d��的基��Q�集合��你能够对数据�q�行分组和处理。例如，你也�怼�创徏一个关于银行交易的集合�Q�该集合代表了某个用��L��银行��水清单。然后，你可能想要处理整个集合去��出该用戯��了多��钱。尽��数据处理十分重要，但Java在此斚w��表现的远不完��?/span>
    首先�Q�典型的集合处理模式与类SQL操作�怼��Q�诸�?查找"(如找出最大金额的那笔交易)或�?分组"(如，��与购买杂货相关的交易进行分�l?。大部分数据库允�怽�以声明的形式��L��定这些操作。例如，后面的SQL查询会让你找到那�W�最大金额交易的ID�Q?SELECT id, MAX(value) from transctions"�?/span>
    如你所见，我们�q�不需要去实现如何计算最大�?例如�Q��用��@环和一个变量去�q�踪�q�个最大�?。我们仅需要表达什么是我们惌��的。这�U�基本思想��意味着�Q�你不太需要担心去昑ּ�地实现这些查�?-它们已经��Z��处理好了。�ؓ什么我们不能在处理集合时也�q�样做呢�Q�你发现自己有多��次都是在一遍又一遍地使用循环去重复实现这些操作呢�Q?/span>
    其次�Q�我们如何才能更高效地去处理大型集合�Q�理��x��况下�Q�在加速进行处理时�Q�你会想到利用多核架构。然而，�~�写�q�行�E�序既困隑֏��Ҏ��出错�?/span>
    Java SE 8赶来帮忙了！Java API的设计者们在升�U�API时引入了一�U�新的称之�ؓJava��?��?的抽象，它允�怽�以声明�Ş式去处理数据。另外，Java��可以利用到多核架构而不必编写一行多�U�程代码。听��h��不错�Q�不是吗�Q�这��是本文章系列所要探�I�的主题�?/span>
    Java��能为我们做些什么呢�Q�在探究�q�些�l�节之前�Q�让我们先看一个例子，�q�样你才能对�q�种新的使用Java SE 8 Java��的�~�程风格有感觉。假设我们要扑ֈ�所有类型�ؓgrocery的交易�ƈ�q�回它们的ID列表�Q��ƈ按交易金额的递减��序对该列表�q�行排序。在Java SE 7中，我们应该会把清单1所�C�的�E�序那样��d��。而在Java SE 8中，我们则会像清�?所�C�的那样��d��现�?/span>
清单1
List<Transaction> groceryTransactions = new Arraylist<>();
for(Transaction t: transactions){
  if(t.getType() == Transaction.GROCERY){
    groceryTransactions.add(t);
  }
}
Collections.sort(groceryTransactions, new Comparator(){
  public int compare(Transaction t1, Transaction t2){
    return t2.getValue().compareTo(t1.getValue());
  }
});
List<Integer> transactionIds = new ArrayList<>();
for(Transaction t: groceryTransactions){
  transactionsIds.add(t.getId());
}

清单2
List<Integer> transactionsIds =
    transactions.stream()
                .filter(t -> t.getType() == Transaction.GROCERY)
                .sorted(comparing(Transaction::getValue).reversed())
                .map(Transaction::getId)
                .collect(toList());

    �?形象地解释了那段Java SE 8�E�序。首先，我们调用List对象中的Java��?)�Ҏ��从交易列�?数据)中获取一个Java��对象。然后，多个操作(�q��o�Q�排序，映射�Q�归�?链接在一起�Ş成了一条线�Q�这条线可以被看作构成了一条数据查询�?/span>

    那么如何�q�行地执行该�E�序呢？在Java SE 8中这很简单：只需要��用parallelJava��?)�Ҏ��L��换Java��?)�Ҏ��Q�如清单3所�C�。Java��?API会在内部对你的查询进行解构，�q�利用上你机器中的多核处理器�?/span>
清单3
List<Integer> transactionsIds =
    transactions.parallelStream()
                .filter(t -> t.getType() == Transaction.GROCERY)
                .sorted(comparing(Transaction::getValue).reversed())
                .map(Transaction::getId)
                .collect(toList());

    在该关于Java SE 8 Java��的文章�p�d��l�束�Ӟ��你将能够使用Java��?API�~�写出像清单3那样的功能强大的查询�E�序�?/span>

Java��入�?/span>
    让我们先从一点理论开始。Java��的定义是什么？一个简短的定义��是"来自于一个数据源的能够支持聚合操作的一串元�?。让我们把它拆开来说�Q?/span>
    一串元�?/strong>�Q�Java��ؓ一串特定类型值的集合提供了一个接口。然后，Java��实际上�q�不存储元素�Q�它们会在需要时被用上�?/span>
    数据�?/strong>�Q�Java��要使用一个提供数据的源，诸如集合对象�Q�数�l�或I/O资源�?/span>
    聚合操作�Q�Java��支持类SQL的操作，以及来自于函数编�E�语�a�的通用操作�Q�诸如过滤，映射�Q�归一�Q�查找，匚w��Q�排序，�{�等�?/span>
    另外�Q�与集合操作非常不同的是�Q�Java��操作拥有两��基本特质：
    ��道�Q�许多Java��操作会�q�回它们自己�Q�这��׃��得这些操作能够链接在一起以�l�成一个大型管道。这样就可以�q�行一些诸如惰性和短�\之类的优化，后面我们会进行探�I��?/span>
    内部遍历�Q�集合是昑ּ�地进行遍�?外部遍历)�Q�但不同于集合，Java��是在幕后进行遍历。让我们重新看看之前的示例代码来解释�q�些原理。图2形象地解释了清单2的更多细节�?/span>

    首先�Q�通过调用Java��?)�Ҏ��Q�我们从交易列表中得��C��一个Java��对象。那么数据源��是交易列表�Q�它��向Java��中提供一串元素。然后，我们对该Java��应用了一�p�d��的聚合操作：�q��o(提供一个谓语去�q��o元素)�Q�排�?提供一个比较器��d��元素�q�行排序)�Q�以及映��?解析��Z��?。所有的操作都会�q�回该Java��，以便能够链接�q�些操作�ȝ��成一个管道，�q�可被看作是�Ҏ��据源的一个查询�?/span>
    在调用collect()操作之前�Q�没有实际工作会被执行。collect()�Ҏ��开始处理这个管道以�q�回一个结�?某个不是Java��的对象�Q�在此处�Q�是一个List对象)。现在还不需要去��x��collect()�Ҏ��Q�我们会在以后的文章��M��探究竟。此�Ӟ��你会发现collect会将各种数据加工�Ҏ��作�ؓ参数�Q�将攉��到的Java��元素归�l��ؓ一个结果。此处，toList()��描�q�C��一个将Java��对象�{化�ؓList对象的加工方法�?/span>
    在探�I�与Java��有关的各个�Ҏ��之前�Q�最好是停下来深入思考一下Java��和集合之间观念上的不同之处�?/span>

Java��?vs. 集合
    已有的Java集合概念与新的Java��概念都��Z��串元素提供了接口。那它们有何不同吗？��单地��_��集合是关于数据的�Q�而Java��是关于计算的�?/span>
    ��x��q�种情况�Q�一部存储在DVD中的电媄。这��是一个集�?可能是字节，可能是��--在此处，我们不必兛_��q�些)�Q�因为它包含有全部的数据�l�构。现在再��x��q�种情况�Q�这部电��p��转化成了数据��，通过互联�|�去观看它。此时它��是一�?字节或��?��。流视频播放器只需要下载一些晚于用户当前所观看位置的�ឮ�可以了。这��P��你就可以在大部分��D��计算出来之前先展�C�流开头处的�?��x��化一场现场直播的��球比赛)�?/span>
    �_�看之，集合与流的区别就是与何时处理数据有关。集合是内存中的数据�l�构�Q�它包含有当前数据结构中的全部�?-��所有元素加入到集合之前�Q�必��d��Ҏ��有元素进行处理，相反圎ͼ�Java��只是逻辑上固定的数据�l�构�Q�它里面的元素只会根据需要进行处理�?/span>
    使用Collection接口�Q�要求用户实现遍�?例如�Q��用增强的for循环�Q�即foreach)�Q�这被称之�ؓ外部循环。相反地�Q�Stream�c�d��使用内部遍历--它已�l��ؓ你实现好了遍历，它会兛_��存储��的�l�果值的位置�Q�你仅需要提供一个函数告诉它要做些什么就行了。清�?(寚w��合的外部遍历)和清�?(对Java��的内部遍历)中的代码形象地展�C�Z��q�一不同之处�?/span>
清单4
List> transactionIds = new ArrayList<>();
for(Transaction t: transactions){
    transactionIds.add(t.getId());
}

清单5
List<Integer> transactionIds =
    transactions.stream()
                .map(Transaction::getId)
                .collect(toList());

    在清�?中，我们昑ּ�且顺序地遍历了交易列表，抽取了每个交易ID�Q�然后将它加��C��个收集器中。相反地�Q�当使用��时�Q�没有显式的遍历。清�?中的代码构徏了一个查询，其中的map操作被设定�ؓ一个参敎ͼ�它会抽取交易ID�Q�然后collect操作会把�l�果Stream对象转化成一个List对象�?/span>
你现在应该知道什么是Java��，以及如何��M��用它。现在让我们看看Java��所支持的操作之间的区别�Q�这样你��p��构徏自己的数据查询了�?/span>

Java��操作：使用��去处理数据
    java.util.stream.Stream接口定义了许多操作，它们可被归集��Z��c�R��在�?所�C�的例子中，你可以看到如下操作：
    �q��o�Q�排序和映射�Q�它们可被连接在一��L��成一个管�?/span>
    攉��Q�它关闭了这个管道�ƈ�q�回�l�果
    能够被连接在一��L��Java��操作被�U�Cؓ中间操作。这些操作之所以能被连接在一��P��是因为它们都会返回Stream对象。这些操作从�q�个��道中返回结果，�l�果的类型可以是List�Q�Integer�Q�甚��x��void(��M��Stream以外的类�?
    你也许很好奇��Z��么这�U�区别很重要。是�q�样的，在这个Java��管道的最�l�操作被调用之前�Q�中间操作�ƈ不会执行��M��处理�Q�它们是"惰�?�Ҏ��。这是因��Z��间方法经�怼��?合�ƈ"�Q�在最�l�操作中它们会被合成为单一的执行�\径�?/span>
清单6
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
List<Integer> twoEvenSquares =
    numbers.stream()
           .filter(n -> {
                    System.out.println("filtering " + n);
                    return n % 2 == 0;
                  })
           .map(n -> {
                    System.out.println("mapping " + n);
                    return n * n;
                  })
           .limit(2)
           .collect(toList());

    例如�Q�思考下清单6中的�E�序�Q�它是从�l�定的数列中计算奇数的��^斏V��你可能会很惊讶�Q�它打印出如下结果：
filtering 1
filtering 2
mapping 2
filtering 3
filtering 4
mapping 4

    �q�是因�ؓlimit(2)使用了短路；我们只需要处理流的一部分�Q�而不是全部，��d��C��个结果。这��q��g��评一个由and操作�W�关联�v来的大型布尔表达式链�Q�一旦某个表辑ּ��q�回了false�Q�那么就可以认�ؓ整个表达式链��是false�Q�而不必测评所有的表达式了。在�q�个例子中，limit()�Ҏ��返回的Java��的长度限定�?。另外，filter与map被合�q�在了同一条执行�\径中了�?/span>

    归纳一下到目前为止�Q�在使用Java��时我们所学到的内容，总言之，涉及三个斚w��Q?/span>
    一个数据源(例如一个集�?�Q�对它执行查�?/span>
    一个中间操作的链，它组成一个流的管�?/span>
    一个最�l�操作，它执行流的管道�ƈ产生�l�果
    现在让我们看看Java��所支持的一些操作。参考java.util.stream.Stream接口可以得到�q�些�Ҏ��的完整清单，再看看本文末��所�l�出的资源，它包含有更多的例子�?/span>

    �q��o。有多种�Ҏ��可以�Ҏ��中的元素�q�行�q��o�Q?/span>
    filter(Predicate)�Q��用一个谓�?java.util.function.Predicate)作�ؓ参数�Q�它会返回一个包含所有匹配给定谓语条件元素的Java��?/span>
    distinct�Q�返回一个包含有唯一元素的Java��?/span>
    limit(n)�Q�返回的��的长度不能��过n�?/span>
    skip(n)�Q�返回的��将不包括前n个元素�?/span>

    查找与匹�?/strong>。一个通用的数据处理模式就要考虑一些元素是否匹配给定的属性。你可以使用anyMatch�Q�allMatch和noneMatch�Ҏ��帮你做到�q�一炏V��这些方法都会��用一个谓语参数�ƈ�q�回boolean��g��为结�?所以，它们是最�l�操�?。例如，使用allMatch��L��Z��易流中所有金额大�?00的交易，如清�?所�C��?/span>
清单7
boolean expensive =
    transactions.stream()
                .allMatch(t -> t.getValue() > 100);

    另外�Q�Stream接口提供了方法findFirst和findAny�Q�以取出��中��M��元素。它们可以与其它的流操作�Q�如filter�Q�结合�v来��用。findFirst和findAny都会�q�回一个Optinal对象(见清�?)�?/span>
清单8
Optional<Transaction> =
    transactions.stream()
                .findAny(t -> t.getType() == Transaction.GROCERY);

    Optional�c?java.util.Optional)是一个容器类�Q�它代表一个存在或不存在的倹{��清�?中的�E�序�Q�findAny�Ҏ��可能没有扑ֈ��M��c�d��为grocery的交易。Optional�c�d��含多个方法去��试一个元素是否存在。例如，如果交易存在�Q�通过使用ifPresent�Ҏ��Q�我们可以选择一个操作去应用�q�个Optaional对象�Q�如清单9所�C?此处只是打印交易)�?/span>
清单9
transactions.stream()
              .findAny(t -> t.getType() == Transaction.GROCERY)
              .ifPresent(System.out::println);

    映射。Java��支持map�Ҏ��Q�它使用一个函�?java.util.function.Function)作�ؓ参数�Q�将��元素投影到其它形式。这个函��C��被应用到每个元素�Q��ƈ��元�?映射"到新的元素�?/span>
    例如�Q�你可能会想��C��用它��L��取流中每个元素的信息。在清单10的例子中�Q�我们返回了一个列表中每个字的长度�?/span>
清单10
List<String> words = Arrays.asList("Oracle", "Java", "Magazine");
List<Integer> wordLengths =
    words.stream()
         .map(String::length)
         .collect(toList());

    归一。到目前为止�Q�我们已见过的最�l�操作会�q�回boolean(allMatch�{�等)�Q�void(forEach)或Optaional对象(findAny�{�等)。我们也使用collect�Ҏ��Stream对象中的所有元素放��C��个List对象中�?/span>
    然而，你也可以��流中的元素攑ֈ�一个查询中�Q�该查询可表达更为复杂的数据处理�Q�例�?拥有最大ID"或�?��出所以交易金额的�?。这��可能对Java��用上reduce�Ҏ��Q�该�Ҏ��会对每个元素重复地应用一个操�?例如�Q�加上两个数�?�Q�直到生成结果。在函数式编�E�中�Q�这常被�U�Cؓ折叠操作。因��操作可被看作重复�?折叠"一张很长的�U?Stream对象)�Q�直到这张纸的面�U�变得只有一点儿了。这��是折叠操作的结果�?/span>
    看看我们是如何��用��@环去计算一个组数字的和会有助于理解�q�个问题�Q?/span>
int sum = 0;
for (int x : numbers) {
  sum += x;
}

    列表中的每一个数字元素都被�P代地�l�合在一��P��q��用一个额外的操作�W�去产生�l�果。本质上�Q�我们就是把一�l�数�?归一"成一个数字。在�q�段代码中有两个参数�Q�数字和变量的初始��|��卌��例中�?�Q�以及用于合�q�所有元素的操作�W�，��x��例中�?�?/span>
清单11
int sum = numbers.stream().reduce(0, (a, b) -> a + b);

    对Java��用reduce�Ҏ��Q�我们可以计��出��中的所有元素��g��和，如清�?1所�C�。reduce�Ҏ��使用两个参数�Q?/span>
    初始��|��0
    BinaryOperation�Q�合�q�两个元素，�q��生一个新�?/span>
    reduce�Ҏ��本质上就是重复应用模式的抽象。其它的查询�Q�如"计算产量"�?计算最大�?(如清�?2所�C?则是reduce�Ҏ��的特别实例�?/span>
清单12
int product = numbers.stream().reduce(1, (a, b) -> a * b);
int product = numbers.stream().reduce(1, Integer::max);

数字��?/span>
    你已�l�看到可以��用reduce�Ҏ��去计��整数流的和。然后，�q�也是有成本的：我们重复执行了许多拆��操作以��Integer对象加到一赗��如果我们能调用一个sum�Ҏ��Q��ɽE�序的意图更为明显，��像清单13那样�Q�岂不是更好�Q?/span>
清单13
int statement =
    transactions.stream()
                .map(Transaction::getValue)
                .sum(); // error since Stream has no sum method

    Java 8引入的三个特定的基本数据�c�d��的流接口来应对这个问�?-IntStream�Q�DoubleStream和LongStream--它们专注于元素分别�ؓint�Q�double和long型的Java��。将一个流转化为特定类型的��，你最�怋�用的�Ҏ��是mapToInt�Q�mapToDouble和mapToLong。这些方法与我们较早前看到的map�Ҏ��是一��L��Q�但它们会返回特定类型的Stream对象�Q�而不是Stream对象。例如，我们可以改进下清�?3中的代码�Q�如清单14所�C�那栗��你也可以��用装��操作将一个基本数据类型的��{化成一个��用包装对象的��?/span>
清单14
int statementSum =
    transactions.stream()
                .mapToInt(Transaction::getValue)
                .sum(); // works!

    最后，数字��的另一�U�有用的形式是数字区间。比如，你可能想生成介于1�?00之间的所有数字。�ؓ了帮助生成这�U�区��_��Java SE 8在IntStream�Q�DoubleStream和LongStream中分别引入了两个静态方法：range和rangeClosed�?/span>
    �q�两个方法都会��用两个参敎ͼ��W�一个参数是起始��|��W�二个参数是�l�止倹{��但是range�Ҏ��生成的区间不会包含终止值本�w�，但rangeClosed生成的区间则会包含。清�?5是一个��用rangeClosed�Ҏ��的例子，它返回一个包含有全部介于10�?0之间奇数的流�?/span>
清单15
IntStream oddNumbers =
    IntStream.rangeClosed(10, 30)
             .filter(n -> n % 2 == 1);

构徏��?/span>
    有多�U�途径可以��L��Z��个流。你已经看过如何从集合对象中构徏��。另外，我们�q�操控过数字��。你也可以从��|��数组或文件中��d��建流。另外，你甚至于可以从一个函��C��生成无限��?/span>
    可以直截了当��C��值或数组中创建流�Q�只需要��用一些静态方法即可，对于��|��是Stream.of()�Q�而对于数�l�，则要调用Arrays.stream()。如清单16所�C��?/span>
清单16
Stream<Integer> numbersFromValues = Stream.of(1, 2, 3, 4);
int[] numbers = {1, 2, 3, 4};
IntStream numbersFromArray = Arrays.stream(numbers);

    你也可以��一个文件�{化�ؓ其内容行的流�Q��用静态方法Files.lines()卛_��。清�?7��׃��用该�Ҏ��计算了文件中行的数量�?/span>
清单17
long numberOfLines =
    Files.lines(Paths.get(“yourFile.txt”), Charset.defaultCharset())
         .count();

    无限��?/strong>。最后，在�ȝ��本文之前�Q�有一个��o人非常兴奋的��L��。到现在为止�Q�你应该理解到流中的元素是按需生成的。有两个静态方�?-Stream.iterate()和Stream.generate()--可以让你从一个函��C��创徏��。然而，因�ؓ被��用的元素是按需生成的，所以这两个�Ҏ��可以"永远�?生成元素。这��是��Z��么我们称它�ؓ无限��：它就是没有固定大��的��，但它做的事情与一个从固定集合生成的流是一��L��?/span>
    清单18��是一个��用iterate�Ҏ��的例子，它会包含10的所有倍数。iterate�Ҏ��使用一个�v始�?此处�?)和一个Lambda表达�?�c�d��为UnaryOperator)去顺序地生成每一个新倹{�?/span>
清单18
Stream<Integer> numbers = Stream.iterate(0, n -> n + 10);

    我们也可以��用limit�Ҏ��Q�以从一个无限流中得��C��个固定流。如清单19所�C�，可以��流的长度限制�ؓ5�?/span>
清单19
numbers.limit(5).forEach(System.out::println); // 0, 10, 20, 30, 40

�l�论
    Java SE 8引入了Streams API�Q�它让你能够表达更�ؓ复杂的数据处理查询。在本文中，你已见到��可以支持许多操作，诸如�q��o�Q�映��，归一和�P代，把它们结合在一起可以写出简�z�的、更富表现力的数据处理查询。这�U�新的编�E�方法远不同于Java SE 8之前的集合处理。但是，它有许多好处。首先，它利用到了诸如惰性或短�\�q�样的技术，以优化数据处理查询的性能。其�ơ，能够自动地利用上多核架构�Q�以�q�行地处理流。在本文章系�l�的�W�二部分中，我们��探索更高��的操作，例如flatMap和collect。请�l�箋��x��?/span>

John Jiang 2014-07-27 20:54 发表评论

2014�q?4月美国非农业��׃��情况报告(�?

John Jiang — Sun, 04 May 2014 16:12:00 GMT

2014�q?4月美国非农业��׃��情况报告
本文是上周五(2014.05.02)才发布的��国2014�q?4月度非农业就业报�?/a>中的概要部分�Q�与软�g技术毫无干�p�R��这份报告在出台后的极短旉��内对外汇市场造成了极大媄响，�U��a是出于好奇看了一下这份报告，学到了不��英文行业名�U�ͼ�以及英文在数字方面的用法�?2014.05.05最后更�?

    今天�Q�美国劳工统计��v报告�Q?月䆾的全部非农业��׃��人数增加�?88000�Q�而且�׃��率降低了0.4个百分点�Q�达到百分之6.3。就业增长的扩大受益于专业与商业服务业，零售业，��饮业和建筑业�?/span>

家庭调查数据
    �?月䆾�Q�失业率从百分之6.7降到了百分之6.3�Q�失业�h数则�?80万，减少�?3.3万。这两项�l�计展示了前4个月的动态。今�q�以来，�׃��率和�׃��人数分别减少�?.2个百分点�?90万�h�?详见表A-1)
    在主要的力_��者分�l�中�Q?月的�׃��率分别下降了�Q�成�q�男�?5.9%)�Q�成�q�女�?5.7%)�Q�青��年(19.1%)�Q�白�?5.3%)�Q�黑�?11.6%)�Q�以及西班牙�?7.3%)。亚裔的无业率�ؓ5.7%(未扣除季节性因�?�Q�今�q�以来，该值的变化很小�?详见表A-1�Q�A-2和A-3)
    �?月里�Q�再�ơ失业者与新工作者分别减��了41.7万和12.6万�?再次�׃��者之前工作过�Q�但在开始重新找工作之前他们�q�不��作力_��力；而新工作者是指之前从未工作过的�h�?丢掉工作的和只完成��时工作的力_��者的数量减少�?5.3万，辑ֈ�520万�?详见表A-11)
    长期�׃��?指失业时间达到或��过27周的�?的数量在4月䆾减少�?8.7万，辑ֈ�350万；�q�些个体占失业�h数的35.3%。在�q�去�?2个月里，长期�׃��者的数量已经减少�?0.8万�?详见表A-12)
    随着民用力_��力在3月增�?0.3万之后，民用力_��力在4月里减少�?0.6万。在最�q�几个月里，��׃��参与率�ƈ没有昄��出清晰的��势�Q�当前的��g��d��10月的值是相同的。在�q�去�q�个月中�Q�就业者与人口比例没有发生变化(58.9%)�Q�但在过一�q�中略有变化�?详见表A-1)
    ��Z��l�济原因的兼职劳动�?有时候也�U�C��Z��情愿的兼职劳动�?的数量在4月略有变化，辑ֈ�750万。这些个体之所以兼职是�׃��他们的工作时间被削减�Q�或者是他们无法扑ֈ�全职工作�?详见表A-8)
    4月䆾�?20万准待业力_��力，比今�q�早些时候有��d��下降(该数据未扣除季节性因�?。这些个体�ƈ不算作劳动力�Q�尽��他们愿意�ƈ且也可以��d��作，而且在前12个月的某些时候也找过工作。但是他们�ƈ不被计算在失业者中�Q�因为在该调查开始的�?周内�Q�他们�ƈ没有��L��工作�?详见表A-16)
    在这些准待业者中�Q�本月有78.3万就业信心��p��，比今�q�早些时候略有变�?该数据未扣除季节性因�?。就业信心��p��目前�ƈ没有��d��扑ַ�作，因�ؓ他们认�ؓ没有合适他们的工作。剩余的140万准待业者没有去��L��工作的原因则是诸如就学或家庭责�Q�?详见表A-16)

机构调查数据
    全部的非农业��׃��者在4月䆾增长�?8.8万。在�?2个月中，�q�_��每个月增�?9.9万个工作岗位。就业增长在4月里得到了扩大，�q�得益于专业与商业服务业�Q�零售业�Q�餐饮业和徏�{�业的就业增�ѝ�?详见表B-1)
    专业与商业服务业�?月䆾增加�?.5万个��׃��岗位。在�?2个月内，该行业每个月会��^均增�?.5万个��׃��。在本月�Q�该行业的就业增长仍在��l�，其中临时辅助服务�?2.4+�?�Q�公�怸�企业��理(1.2+�?�Q�计��机�pȝ��设计及其相关服务�?0.9+�?�?/span>
    零售业的��׃��岗位在本月增加了3.5万个。在�q�去�?2个月中，该行业的��׃��已经增加�?2.7万。在零售业中�Q�本月的工作岗位增长发生在饮食商�?0.9+�?�Q�日用百货商�?0.8+�?�Q�汽车与雉��件商(0.6+�?和非实体商店(0.4+�?。电子与电器商店在本月则丢失�?.1万工作岗位。批发业在过��M��个月内增加了1.6万个工作岗位�Q�而它在过��M��q�内增加�?2.6万个工作岗位�?/span>
    ��饮业在本月增加的就业数(3.3+�?则与�q�去12个月的��^均增�?2.8�?�?处于同一水��^�U�上�?/span>
    建筑行业的就业在4月䆾增加�?.2万个�Q�这些工作增长分别�ؓ重型和民用工�E�徏�{�业(1.1+�?和住宅徏�{�业(0.7+�?。在�q�去一�q�中�Q�徏�{�业已经增加�?8.9万个工作岗位�Q�而且其中几乎四分之三的增镉K��发生在过�?个月中�?/span>
    �ȝ��行业本月增加�?.9万个岗位�Q�与�q�去12个月的��^均增�?1.7�?�?水��^相持�q�뀂包括会员协会，个�h服务业与�z��业等其它服务性行业的��׃��在这个月内增加了15000个�?/span>
    采矿业在4月䆾增加�?0000个工作岗位，大部分的增长都是在针寚w��矿的支持�z�d��?7000+)�?/span>
    其它主要行业�Q�包括制造业�Q�运输与仓储业，信息服务业，金融服务�Q�以及政府服务业�Q�的��׃��在这个月内少有变化�?/span>
    全部�U�营非农业就业者的�q�_��周工作时间没有变化，仍�ؓ34.5��时。制造业的周工作旉��减少�?.2个小�Ӟ��辑ֈ�40.8个小时。工厂的加班旉��没有变化�Q�仍�?.5个小时。私营非农业��׃��者中的生产与非管理阶层员工的�q�_��周工作时间也没有发生变化�Q�依然�ؓ33.7个小时�?详见B-2和B-7)
    本月�Q�私营非农业��׃��者的�q�_��时薪仍然�?4.31��元。在�q�去12个月中，�q�_��时薪已经增长�?.9%。私营的生��与非��理阶层员工的��^均时薪则增长�?%�Q�达�?0.50��元�?详见表B-3和B-8)
    二月份的全部的非农业��׃��岗位�?9.7+万修正�ؓ22.2+万，而对于三月䆾的这一数据�Q�则是从19.2+万修正�ؓ20.3+万。根据这些修正，二月份与三月份的��׃��增长比之前报告的要高�?.6万个�?br />

John Jiang 2014-05-05 00:12 发表评论

Java 8的语�a�变化(�?

John Jiang — Sat, 19 Apr 2014 15:48:00 GMT

Java 8的语�a�变化
--理解Lambda表达式和变化的接口类是如何��Java 8成�ؓ新的语言
本文是IBM developerWorks中的一��介�l�Java 8关键新特性的文章�Q�它主要��x��Lambda表达式和改进的接口�?2014.04.19最后更�?

    Java 8包含了一�l�重要的新的语言�Ҏ��，使你能够更方便地构造程序。Lambda表达为内联的代码块定义了一�U�新的语法，�l�予你与匿名内部�cȝ��同的灉|��性，但又没有那么多模板代码。接口的改变使得能够为已有接口加入新的特性，而不必打破现有代码的兼容性。了解这些语�a�变化是怎样一起工作的�Q�请阅读本系列另一��文�?Java 8�q�发基础"�Q�可以看到如何在Java 8��中使用Lambda�?/span>
    Java 8的最大改变就是增加了对Lambda表达式的支持。Lambda表达式一�U�通过引用�q�行传递的代码块。它�c�M��于某些其它语�a�的闭包：代码实现了一个功能，可以传入一个或多个参数�Q�还可以�q�回一个结果倹{��闭包被定义在一个上下文中，它可以访�?在Lambda中是只读讉K��)上下文中的倹{�?/span>
    如果你不熟悉闭包�Q�也不必担心。Java 8的Lambda表达式是几乎每个Java开发者都熟悉的匿名内部类的一个高效版规范。如果你只想在一个位�|�实��C��个接口，或是创徏一个基�cȝ��子类�Ӟ��匿名内部�c�Mؓ此提供了一�U�内联实现。Lambda表达式也用于相同的方式，但是它��用一�U�羃略的语法�Q��得这些实现比一个标准的内部�c�d��义更为简�z��?/span>
    在本文中�Q�你��看到如何在不同的场景下使用Lambda表达式，�q�且你会学到与Java接口定义相关的扩展。在本文章的姊妹��JVM�q�发�p�d��?Java 8�q�发基础"一文中�Q�可以看到更多��用Lambda表达式的例子�Q�包括在Java 8��特性中的应用�?/span>

�q�入Lambda
    Lambda表达式就是Java 8所�U�的函数接口的实玎ͼ�一个接口只定义一个抽象方法。只定义一个抽象方法的限制是非帔R��要的�Q�因为Lambda表达式的语法�q�不会��用方法名。相反，该表辑ּ�会��用动态类型识�?匚w��参数和返回类型，很多动态语�a�都这么做)��M��证提供的Lambda能够与期望的接口�Ҏ��兼容�?/span>
    在清�?所�C�的��单例子中�Q�一个Lambda表达式被用来对Name实例�q�行排序。main()�Ҏ��中的�W�一个代码块使用一个匿名内部类��d��现Comparator接口�Q�第二个语句块则使用Lambda表达式�?/span>
清单1. 比较Lambda表达式与匿名内部�c?/span>
public class Name {
    public final String firstName;
    public final String lastName;

    public Name(String first, String last) {
        firstName = first;
        lastName = last;
    }

    // only needed for chained comparator
    public String getFirstName() {
        return firstName;
    }

    // only needed for chained comparator
    public String getLastName() {
        return lastName;
    }

    // only needed for direct comparator (not for chained comparator)
    public int compareTo(Name other) {
        int diff = lastName.compareTo(other.lastName);
        if (diff == 0) {
            diff = firstName.compareTo(other.firstName);
        }
        return diff;
    }

}

public class NameSort {

    private static final Name[] NAMES = new Name[] {
        new Name("Sally", "Smith"),

    };

    private static void printNames(String caption, Name[] names) {

    }

    public static void main(String[] args) {

        // sort array using anonymous inner class
        Name[] copy = Arrays.copyOf(NAMES, NAMES.length);
        Arrays.sort(copy, new Comparator<Name>() {
            @Override
            public int compare(Name a, Name b) {
                return a.compareTo(b);
            }
        });
        printNames("Names sorted with anonymous inner class:", copy);

        // sort array using lambda expression
        copy = Arrays.copyOf(NAMES, NAMES.length);
        Arrays.sort(copy, (a, b) -> a.compareTo(b));
        printNames("Names sorted with lambda expression:", copy);

    }
}
    在清�?中，Lambda被用于取代匿名内部类。这�U�匿名内部类在应用中非常普遍�Q�所以Lambda表达式很快就赢得了Java8�E�序员们的青睐�?在本例中�Q�同时��用匿名内部类和Lambda表达式去实现Name�c�M��的一个方法，以方便对�q�两�U�方法进行比较。如果在Lambda中对compareTo()�Ҏ��q�行内联的话�Q�该表达式将会更加简�z��?

标准的函数式接口
    ��Z��应用Lambda�Q�新的包java.util.function中定义了�q�泛的函数式接口。它们被归结为如下几个类别：
    函数�Q��用一个参敎ͼ��Z��参数的��D��回结果�?/span>
    谓语�Q��用一个参敎ͼ��Z��参数的��D��回布��结果�?/span>
    双函敎ͼ�使用两个参数�Q�基于参数的��D��回结果�?/span>
    供应器：不��用�Q何参敎ͼ�但会�q�回�l�果�?/span>
    消费者：使用一个参敎ͼ�但不�q�回��M��l�果�?/span>
多数�c�d��都包含多个不同的变体�Q�以便能够作用于基本数据�c�d��的参数和�q�回倹{��许多接口所定义的方法都可被用于�l�合对象�Q�如清单2所�C�：
清单2. �l�合谓语
// use predicate composition to remove matching names
List<Name> list = new ArrayList<>();
for (Name name : NAMES) {
    list.add(name);
}
Predicate<Name> pred1 = name -> "Sally".equals(name.firstName);
Predicate<Name> pred2 = name -> "Queue".equals(name.lastName);
list.removeIf(pred1.or(pred2));
printNames("Names filtered by predicate:", list.toArray(new Name[list.size()]));
    清单2定义了一对Predicate变量�Q�一个用于匹配名为Sally的名字，另一个用于匹配姓为Queue的名字。调用方法pred1.or(pred2)会构造一个组合谓语，该谓语先后��用了两个谓语�Q�当它们中的��M��一个返回true�Ӟ��q�个�l�合谓语��将�q�回true(�q�就相当于早期Java中的逻辑操作�W�||)。List.removeIf()�Ҏ��应用这个组合谓语去删除列表中的匚w��名字�?/span>
    Java 8定义了许多有用的java.util.function包中接口的组合接口，但这�U�组合�ƈ不都是一��L��。所有的谓语的变�?DoublePredicate�Q�IntPredicate�Q�LongPredicate和Predicate)都定义了相同的组合与修改�Ҏ��Q�and()�Q�negate()和or()。但是Function的基本数据类型变体就没有定义��M��l�合与修�Ҏ��法。如果你拥有使用函数式编�E�语�a�的经验，那么你可能就发会发现�q�些不同之处和奇怪的忽略�?/span>

改变接口
    在Java 8中，接口(如清�?的Comparator)的结构已发生了改变，部分原因是�ؓ了让Lambda更好用。Java 8之前的接口只能定义常量，以及必须被实现的抽象�Ҏ��。而Java 8中的接口则能够定义静态与默认�Ҏ��。接口中的静态方法与抽象�c�M��的静态方法是完全一��L��。默认方法则更像旧式的接口方法，但提供了该方法的一个实现。该�Ҏ��实现可用于该接口的实现类�Q�除非它被实现类覆盖掉了�?/span>
    默认�Ҏ��的一个重要特性就是它可以被加入到已有接口中，但又不会破坏已��用了�q�些接口的代码的兼容�?除非已有代码恰��y使用了相同名字的�Ҏ��Q��ƈ且其目的与默认方法不�?。这是一个非常强大的功能�Q�Java 8的设计者们利用�q�一�Ҏ��ؓ许多已有Java�c�d��加入了对Lambda表达式的支持。清�?��展�C�Z��q�样的一个例子，它是清单1中对名字�q�行排序的第三种实现方式�?/span>
清单3. �?提取比较器链
// sort array using key-extractor lambdas
copy = Arrays.copyOf(NAMES, NAMES.length);
Comparator<Name> comp = Comparator.comparing(name -> name.lastName);
comp = comp.thenComparing(name -> name.firstName);
Arrays.sort(copy, comp);
printNames("Names sorted with key extractor comparator:", copy);
    清单3首先展示了如何��用新的Comparator.comparing()静态方法去创徏一个基于键-提取(Key-Extraction) Lambda的比较器(从技术上看，�?提取Lambda��是java.util.function.Function接口的一个实例，它返回的比较器的�c�d��适用于类型T�Q�而提取的键的�c�d��R则要实现Comparable接口)。它�q�展�C�Z��如何使用新的Comparator.thenComparing()默认�Ҏ��ȝ��合��用比较器�Q�清�?��p��回了一个新的比较器�Q�它会先按姓排序�Q�再按名排序�?/span>
    你也许期望能够对比较器进行内联，如：
Comparator<Name> comp = Comparator.comparing(name -> name.lastName)
    .thenComparing(name -> name.firstName);
但不�q�地是，Java 8的类型推��g��允许�q�么做。�ؓ从静态方法中得到期望�c�d��的结果，你需要�ؓ�~�译器提供更多的信息�Q�可以��用如下�Q何一�U��Ş式：
Comparator<Name> com1 = Comparator.comparing((Name name1) -> name1.lastName)
    .thenComparing(name2 -> name2.firstName);
Comparator<Name> com2 = Comparator.<Name,String>comparing(name1 -> name1.lastName)
    .thenComparing(name2 -> name2.firstName);
    �W�一�U�方式在Lambda表达式中加入参数的类型：(Name name1) -> name1.lastName。有了这个辅助信息，�~�译才能知道下面它该做些什么。第二种方式是告诉编译器要传递给Function接口(在此处，该接口通过Lambda表达式实�?中comparing()�Ҏ��的泛型变量T和R的类型�?/span>
    能够方便地构建比较器以及比较器链是Java 8中很有用的特性，但它的代��h��增加了复杂度。Java 7的Comparator接口定义了两个方�?compare()�Ҏ��Q�以及遍布于每个对象中的equals()�Ҏ��)。而在Java 8中，该接口则定义�?8个方�?除了原有�?个方法，�q�新加入�?个静态方法和7个默认方�?。你��发玎ͼ��Z��能够使用Lambda而造成的这�U�接口膨胀会重��C��相当一部分Java标准�c�d��中�?/span>

像Lambda那样使用已有�Ҏ��
    如果一个存在的�Ҏ��已经实现了你的需求，你可以直接��用一个方法引用对它进行传递。清�?展示了这�U�方法�?/span>
清单4. 对已有方法��用Lambda

// sort array using existing methods as lambdas
copy = Arrays.copyOf(NAMES, NAMES.length);
comp = Comparator.comparing(Name::getLastName).thenComparing(Name::getFirstName);
Arrays.sort(copy, comp);
printNames("Names sorted with existing methods as lambdas:", copy);
    清单4做着与清�?相同的事情，但它使用了已有方法。��用Java 8的�Ş�?�c�d��:�Ҏ��?的方法引用语法，你可以��用�Q意方法，��像Lambda表达式那栗��其效果��׃��你定义一个Lambda表达式去调用该方法一栗��对�cȝ��静态方法，特定对象或Lambda输入�c�d��的实例方�?如在清单4中，getFirstName()和getLastName()�Ҏ��是Name�cȝ��实例�Ҏ��)�Q�以及类构造器�Q�都可以使用�Ҏ��引用�?/span>
    �Ҏ��引用不仅方便�Q�因为它们比使用Lambda表达式可能更高效�Q�而且为编译器提供了更好的�c�d��信息(�q�也��是��Z��么在上一节的Lambda中��?thenComparing()构造Comparator会出现问题，而在清单4却能正常工作)。如果既可以使用对已有方法的�Ҏ��引用�Q�也可以使用Lambda表达式，请��用前者�?/span>

捕获与非捕获Lambda
    你在本文中已见过的Lambda表达式都是非捕获的，意即�Q�它们都是把传入的值当作接口方法参��C��用的��单Lambda表达式。Java 8的捕获Lambda表达式则是��用外围环境中的倹{��捕获Lambda�c�M��于某些JVM语言(如Scala)使用的闭包，但Java 8的实��C��之有所不同�Q�因为来自在外围环境中的值必��d��明�ؓfinal。也��是��_��q�些��D��么确实�ؓfinal(��如同以前的Java版本中由匿名内部�c�L��引用的�?�Q�要么在外围环境中不会被修改。这一规范适用于Lambda表达式和匿名内部�c�R��有一些方法可以绕�q�对值的final限制。例如，在Lambda中仅使用特定变量的当前��|��你可以添加一个新的方法，把这些��g��为方法参敎ͼ�再将捕获的�?以恰当的接口引用�q�种形式)�q�回�l�Lambda。如果期望一个Lambda��M��改外围环境中的��|��那么可以用一个可修改的持有器�c?Holder)对这些��D��行包装�?/span>
    相比于捕获Lambda�Q�可以更高效地处理非捕获Lambda�Q�那是因为编译能够把它生成�ؓ�c�M��的静态方法，而运行时环境可以直接内联的调用这些方法。捕获Lambda也许低效一些，但在相同上下文环境中它至��可以表现的和匿名内部类一样好�?/span>

�q�后的Lambda
    Lambda表达式看��h��像匿名内部类�Q�但它们的实现方法不同。Java的内部类有很多构造器�Q�每个内部类都会有一个字节码�U�别的独立类文�g。这��׃��产生大量的重复代�?大部分是在常量池实体�?�Q�类加蝲时会造成大量的运行时开销�Q�哪怕只有少量的代码也会有如此后果�?/span>
    Java 8没有为Lambda生成独立的类文�g�Q�而是使用了在Java 7中引入的invokedynamic字节码指令。invokedynamic作用于一个启动方法，当该�Ҏ��W�一�ơ被调用时它会�{而去创徏Lambda表达式的实现。然后，该实��C��被返回�ƈ被直接调用。这样就避免了独立类文�g带来的空间开销�Q�以及加载类的大量运行时开销。确切地��_��Lambda功能的实现被丢给了启动程序。目前Java 8生成的启动程序会在运行时为Lambda创徏一个新�c�，但在��来会��用不同的�Ҏ��d��现�?/span>
    Java 8使用的优化��得通过invokedynamic指��o实现的Lambda在实际中�q�行正常。多数其它的JVM语言�Q�包括Scala (2.10.x)�Q�都会�ؓ闭包使用�~�译器生成的内部�c�R��在��来�Q�这些语�a�可能会�{而��用invokedynamic指��o�Q�以便利用到Java 8(及其后��版本)的优化�?/span>

Lambda的局�?/span>
    如在本文开始时我所提到的，Lambda表达式��L��某些�Ҏ��函数式接口的实现。你可以仅把Lambda当作接口引用��M��递，而对于其它的接口实现�Q�你也可以只是把Lambda当作�q�些特定接口��M��用。清�?展示了这�U�局限性，在该�C�Z��使用了一对相同的(名称除外)函数式接口。Java 8�~�译接受String::lenght来作��两个接口的Lambda实现。但是，在一个Lambd表达式被定义为第一个接口的实例之后�Q�它不能够用于第二个接口的实例�?/span>
清单5. Lambda的局�?/span>
private interface A {
    public int valueA(String s);
}
private interface B {
    public int valueB(String s);
}
public static void main(String[] args) {
    A a = String::length;
    B b = String::length;

    // compiler error!
    // b = a;

    // ClassCastException at runtime!
    // b = (B)a;

    // works, using a method reference
    b = a::valueA;
    System.out.println(b.valueB("abc"));
}
    ��M��对Java接口概念有所了解的�h都不会对清单5中的�E�序感到惊讶�Q�因为那��是Java接口一直所做的事情(除了最后一点，那是Java 8新引入的�Ҏ��引用)。但是��用其它函数式�~�程语言�Q�例如Scala�Q�的开发者们则会认�ؓ接口的这�U�限制是不自然的�?/span>
    函数式编�E�语�a�是用函数�c�d��Q�而不是接口，��d��义变量。在�q�些�~�程语言中会很普遍的使用高��函数�Q�把函数作�ؓ参数传递给其它的函敎ͼ�或者把函数当作值去�q�回。其�l�果��是你会得到比Lambda更�ؓ灉|��的编�E�风��|��q�包括��用函数去�l�合其它函数以构��句块的能力。因为Java 8没有定义函数�c�d��Q�你不能使用�q�种�Ҏ��ȝ��合Lambda表达式。你可以�l�合接口(如清�?所�C?�Q�但只能是与Java 8中已写好的那些接口相关的特定接口。仅在新的java.util.function包内�Q�就�Ҏ��讑֮��?3个接口去使用Lambda。把它们加入到数以百计的已有接口中，你将看到�q�种�Ҏ��在组合接口时��L��会有严重的限制�?/span>
    使用接口而不是在向Java中引入函数类型是一个精妙的选择。这样就在防止对Java�c�d��q�行重大改动的同时也能够对已有类库��用Lambda表达式。它的坏作用��是对Java 8造成了极大的限制�Q�它只能�U�Cؓ"接口�~�程"或是�c�d��数式�~�程�Q�而不是真正的函数式编�E�。但依靠JVM上其它语�a��Q�也包括函数式语�a��Q�的优点�Q�这些限制�ƈ不可怕�?/span>

�l�论
    Lambda是Java语言的最主要扩展�Q�伴着它们的兄弟新�Ҏ�?-�Ҏ��引用�Q�随着�E�序被移植到Java 8�Q�Lambda��很快成为所有Java开发者不可或�~�的工具。当与Java 8��结合�v来时�Q�Lambda��q��别有用。查看文�?JVM�q�发: Java 8�q�发基础"�Q�可以了解到��Lambda和流�l�合��h��使用是如何简化�ƈ发编�E�以及提高程序效率的�?/span>

John Jiang 2014-04-19 23:48 发表评论

Java��的8个特�?�?

John Jiang — Fri, 28 Feb 2014 07:25:00 GMT

Java��的8个特�?/span>
本文是稍早前java.net推荐的一��?/span>博文�Q�描�q�C��Java��的8个有用的�Ҏ��?2014.03.07最后更�?

Lamba表达式是Java8到目前�ؓ止最��的�Ҏ��。但我认为有一个秘密武器展�C�Z��Lambda�q�一"语法�p?在提高代码可��L��和可写性方面是何其的强大。当你在改进代码的表现力�Ӟ��那么在对代码的理解方面你��׃��升到了新的境界，�q�能使最�W�拙的工作变得简单�?/span>

是什么秘密武器呢�Q�就是Java Stream API。最�q�我参与了一个在�U�比赛，��是在一个对性能要求较高的环境中��单地使用Java Stream。��o我惊讶的是，�q�个API让编写主要的循环�E�序变得十分��单，而且能很好地适应我所做出的众多变化。下面就是我所学到�?个特性�?/span>

1. Java��不需要Lambda表达�?/strong>
��管�q�个API��实从Lambda表达式中获准良多�Q�但你�ƈ不必非得使用Lambda。你可以回过��M��用匿名内部类�Q�但��Z��么要�q�么做呢�Q�较可能的场景是�Q��用一个方法引�?例如Integer::valueOf)�Q�或者一个实例对象。��用方法引用可��复杂的多行逻辑�|�于循环体之外，��如你在优化一个hash set查找时所看到的。而实例对象可用于实现"四�h�?的策略模式。但请不要��用匿名内部类�Q�除非你不得不这么做�?br />
2. �H�入��内�q�行调试
你可以在��的��M��位置攑օ�你所惛_��q�去的媒质，�q�个媒质�U�Cؓpeek。该操作使用了一个消费者对象，�q�期望不产生��M��l�果�Q�因为Lambda一般只�q�回�I�。我喜欢把peek用于向系�l�发送调试信息，��如
.peek(System.out::println)
.peek(it -> System.out.printf("it is %s%n", it)

3. ��化随机成员
��ƈ不局限于集合或数�l�，甚至是固定链表。如果你能创��Z��个Iterator或Supplier Lambda来创建流中的��|��然后你就可以使用�c�java.util.stream.StreamSupport中的�Ҏ��来创��Z��个流了。可以设想一个��用持�l�测量��|��如内存消耗量或网�l�吞量，来驱动的��?br />
4. ��化随机�?/strong>
如果你正在寻找一个简单的随机敎ͼ�例如可以通过java.util.Random�Q�这个类现在有了三个新的set�Ҏ��ints()�Q�longs()和doubles()来创建流。这些方法的重蝲版本可以让你讄��边界�Q�随机种子以及流中随机数的总量�?br />
5. ��化I/O Reader
Java�E�序员的另一个常见工作就是一行一行地解析文�g。现在java.io.BufferedReader有了一个新�Ҏ��lines()�Q�它会将I/O��{化�ؓ一个字�W�串��，以便于流的处理�?br />
6. ��化文�g�?/strong>
如果讉K��的文件�ƈ不是你的菜，那就试试讉K��一个文件树会怎么��P��c�java.nio.file.Files中有几个�Ҏ��都可以返回流。list()�Ҏ��列��Z��个目录下的所有文�Ӟ��walk()�Ҏ��会递归地做到这一点，而filter()�Ҏ��也会递归地访问这些文�Ӟ��但会使用一些属性来�q�行�q��o(当你有一个Path对象�Q�有些事情会变得复杂��h��)。你依然可以使用lines(Path)�Ҏ��来通过��去获取内容�?br />
7. ��化复杂文本
如果你依然念念不忘文本处理，但内容�ƈ不是��Z��行，那么��可以在java.util.regex.Pattern实例中��用splitAsStream(CharSequence)�Ҏ��。这对于处理有数百万列的CSV文�g或CLASSPATH十分有用�?br />
8. ��化ZIP文�g
说到寚w��CLASSPATH的搜索，你也可以很简单地调用名�ؓstream的方法来��化java.util.zip.ZipFiles和java.util.jar.JarFiles�Q�它会相应地�q�回一个ZipEntry或JarEntry实例�?br />
如果你都已经�q�过�q�些事了�Q�那么你肯定知道它们�q�不是Java��的基本用途。不�q�将来会有��够多的博文去涉及Java��的基础。我只是认�ؓ上述�q�些都是被掩藏�v来的宝藏�Q�它们揭�C�Z��Java��的潜质�?/div>

John Jiang 2014-02-28 15:25 发表评论

使用Gradle构徏Java Web应用(�?

John Jiang — Thu, 23 Jan 2014 13:22:00 GMT

使用Gradle构徏Java Web应用
本文是发布在java.net上的一��摘自于一书中�?a >节�?/a>�Q�介�l�了使用Gradle构徏Java Web应用的过�E�。刚刚接触Gradle�Q�看��C��q�篇��文�Q�随手译了出�?-) (2014.01.23最后更�?

当今世界�Q�一�z��忙。在职业生��和私人生�z�M��Q�我们中间的许多��同时��理多个��目。你可能常常发现自己处于不知所措及失控的状态。保持规整�ƈ专注于�h值的关键是一个维护良好的工作清单。当�Ӟ��你可能��L��把你的�Q务写在一张纸上，但是你也�怸�可能在你所处的��M��地方都可方便地获得这些工作条目？对互联网的访问几乎是无处不在的，无论是通过你的�U�d��电话�Q�还是公��q��|�络接入炏V��在一书中�Q�如�?所�C�的说明性示例是一个很有吸引力的可视化Web应用�?/span>

�? To Do应用可以通过互联�|�进行访问，�q��用它�ȝ��理数据存储中的工作条�?/strong>

Gradle插�g表现的如同一个��能器�Q�它会自动地执行�q�些��d��。一个插仉��过引入特定领域的规范以及对�~�省值敏感的��d��d��工程�q�行扩展。随Gradle发布的插件之一��是Java插�g。该Java插�g�l�不仅仅是提供了源码�~�译和打包这��L��基础功能。它为工�E�徏立了一整套标准的目录布局�Q�它会确保以正确的顺序去执行��d��Q�这��P��q�些��d��在Java工程环境中才是有意义的。现在是时候�ؓ我们的应用去创徏一个构��本�ƈ��M��用这个Java插�g了�?/span>

构徏Java应用
一开始，每个Gradle工程都会创徏一个名为build.gradle的构��本。�ؓ了创��脚本�Q��ƈ告诉该工�E��用Java插�g�Q�应该像�q�样��d��Q?/span>

apply plugin: 'java'
��Z��构徏你的Java代码�Q�一行代码就够了。但Gradle怎么知道��d��儿找你的源文件呢�Q�该Java插�g引入的规范之一��是源代码的路径。默认地�Q�该插�g会到目录src/main/java中搜��M�品的源代码�?/span>

构徏Web应用
通过War插�g�Q�Gradle也提供了构徏Web应用的扩展支持。War插�g扩展了Java插�g�Q�它加入了针对Web应用�E�序开发的规范�Q��ƈ支持归集WAR文�g。让我们也在�q�个工程中用用War插�g�Q?/span>

apply plugin: 'war'
Web应用源文件的默认路径是src/main/webapp。假设你已经明确了该应用所必要的Java�c�R��那么要使��品的全部源代码和Web资源文�g处于正确路径下，该工�E�的目录布局应该像下面这��P��

.
├── build.gradle
└── src
    └── main
        ├── java
        │   └── com
        │       └── manning
        │           └── gia
        │               └── todo
        │                   ├── model
        │                   │   └── ToDoItem.java
        │                   ├── repository
        │                   │   ├── InMemoryToDoRepository.java
        │                   │   └── ToDoRepository.java
        │                   └── web
        │                       └── ToDoServlet.java
        └── webapp                                               #A
            ├── WEB-INF
            │   └── web.xml                                      #B
            ├── css                                              #C
            │   ├── base.css
            │   └── bg.png
            └── jsp                                              #D
                ├── index.jsp
                └── todo-list.jsp

#A Web源文仉��认目�?br /> #B Web应用描述�W�文�?br /> #C 存储描述如何展现HTML元素的样式单文�g的目�?br /> #D 存放JSP形式的动态脚本化视图�l��g

声明外部依赖
在实现这个Web应用的过�E�，我们使用的一些类�Q�例如javax.servlet.HttpServlet�Q��ƈ非Java标准�?Java SE)的一部分。在构徏工程之前�Q�我们需要确保已�l�声明了�q�些外部依赖。在Java�pȝ��中，依赖�c�d��是以JAR文�g的�Ş式去发布和��用的。许多类库可以从仓库�Q�如一个文件系�l�或中央服务器，中获得。�ؓ了��用依赖，Gradle要求你至��定义一个仓库。出于一些考虑�Q�我们将使用公共的可通过互联�|�进行访问的Maven Central仓库�?/span>

repositories {
   mavenCentral()                   #A
}
#A 通过http://repo1.maven.org/maven2讉K��Maven2中央仓库的简短标�?/span>
在Gradle中，依赖是通过配置��Ҏ��q�行分组的。我们将来Servlet依赖使用的配�|�项是providedCompile。该配置��用于那些在�~�译时而非�q�行时所需的依赖。像JSTL�q�样的运行时依赖�Q�在�~�译时不会被用到�Q�但在运行时则会被用到。它们都会成为WAR文�g的一部分。下面的配置语句块声明了我们应用所需的外部类库：

dependencies {
   providedCompile 'javax.servlet:servlet-api:2.5'
   runtime 'javax.servlet:jstl:1.1.2'
}

构徏工程
我们已经准备好构��个工�E�了。另到工�E�中的一个Java插�g��d��名�ؓbuild。该��d��编译源代码�Q�运行测试程序�ƈ归集WAR文�g--所有的�q�些��d��都将以正��的��序被执行。执行命令gradle build之后�Q�你可能会得到�Ş如下面的输出�Q?/span>

$ gradle build
:compileJava                                      #A
:processResources UP-TO-DATE
:classes
:war                                              #B
:assemble
:compileTestJava UP-TO-DATE                       #C
:processTestResources UP-TO-DATE
:testClasses UP-TO-DATE
:test                                             #D
:check
:build

#A �~�译产品的Java源代�?br /> #B War插�g提供的�Q务，用于归集WAR文�g
#C �~�译Java��试源代�?br /> #D �q�行单元��试

上述输出的每一行都代表执行了一个由Java或War插�g提供的�Q务。你可能会注意到�Q�有一些�Q务被标记为UP-TO-DATE。它的意思是指该��d��被蟩�q�去了。Gradle的增量构建支持策略会自动识别不需要执行的工作。特别是在大型商业项目中�Q�该�Ҏ��会极大地节省时间�?/span>
在该工程的根节目录中�Q�你��会发现一个名为build的子目录�Q�它包含有执行构��Z��后的全部输出�Q�包括类文�g�Q�测试报告，归集的WAR文�g�Q�以及像manifest�q�样的在打包旉��要的临时文�g。如下就是执行构建工作之后的工程目录�l�构�Q?/span>

.
├── build
│   ├── classes
│   │   └── main                                          #A
│   │       └── com
│   │           └── manning
│   │               └── gia
│   │                   └── todo
│   │                       ├── model
│   │                       │   └── ToDoItem.class
│   │                       ├── repository
│   │                       │   ├── InMemoryToDoRepository.class
│   │                       │   └── ToDoRepository.class
│   │                       └── web
│   │                           ├── ToDoServlet$ToDoListStats.class
│   │                           └── ToDoServlet.class
│   ├── dependency-cache
│   ├── libs
│   │   └── todo-webapp.war                               #B
│   ├── reports
│   │   └── tests
│   │       ├── base-style.css
│   │       ├── css3-pie-1.0beta3.htc
│   │       ├── index.html
│   │       ├── report.js
│   │       └── style.css
│   ├── test-results
│   │   └── binary
│   │       └── test
│   │           └── results.bin
│   └── tmp
│       └── war
│           └── MANIFEST.MF                                #C
├── build.gradle
└── src

#A 包含Java�c�L��件的默认目录
#B 归集的WAR文�g
#C 用于WAR的��时manifest文�g
你已�l�知道如何从一个基于标准目录结构的Web工程��L��建WAR文�g。现在是时候将它布�|�到一个Servlet容器中去了。在下一节中�Q�我们将在本地开发机器中启动Jetty去运行这个Web应用�?/span>

�q�行应用
在本地机器中�q�行一个Web应用应该很容易，能够实践快速应用开�?RAD)�Q��ƈ能够提供快速的启动旉��。最��地是，它不要求你部�|�一个Web容器�q�行时环境。Jetty一个流行的轻量�U�开源Web容器�Q�它支持前面提到的所有特性。在�q�个Web应用中加入一个HTTP模块�Q�它��变成了一个嵌入式实现。Gradle的Jetty插�g扩展了War插�g�Q�它提供的�Q务可以将一个Web应用部��v到嵌入式容器中，�q�能够启动该应用。在你的构徏脚本中，可以像如下那样��用这个插�Ӟ��

apply plugin: 'jetty'
�q�个��被我们用于启动Web应用的�Q务名为jettyRun。它甚至可以在无需创徏WAR文�g的情况下启动一个Jetty容器。执行上�q�命令后会得到如下�Ş式的输出�Q?/span>

$ gradle jettyRun
:compileJava
:processResources UP-TO-DATE
:classes
> Building > :jettyRun > Running at http://localhost:8080/todo-webapp-jetty
在上�q�输出的最后一行中�Q�该插�g告诉了你Jetty卛_��侦听的请求地址。打开一个你喜欢的浏览器�Q��ƈ输入上述地址。最后，我们会看到这个To Do Web应用的行为。图2展示在一个浏览器中查看到该应用界面的截屏�?/span>

�? To Do应用的Web界面及其行�ؓ

在你通过�l�合键CTRL+C��d��止这个应用之前，Gradle会让它一直运行。Jetty如何知道使用哪个端口和上下文环境去运行这个Web应用�Q�再说一遍，�q�就是规范。Jetty�q�行Web应用所使用的默认端口就�?080�?/span>

�ȝ��
只需要较��的努力�Q�你��可以��用Gradle��L��建�ƈ�q�行一个Java Web应用。只要你严格遵��@标准目录�l�构�Q�那么你的构��本仅需要两行代码�?/span>

John Jiang 2014-01-23 21:22 发表评论

Java�q�发基础实践--死锁(�?

John Jiang — Sun, 29 Dec 2013 12:19:00 GMT

Java�q�发基础实践--死锁
本文�?a href="http://www.dentisthealthcenter.com/jiangshachina/category/53896.html">Java�q�发基础实践�p�d��中的一��，介绍了最��单的死锁场景�Q��ƈ使用jstack产生的thread dump来查找死锁�?2013.12.29最后更�?

1. 死锁
��Z��能够�l�护�U�程的安全性，Java提供的锁机制�Q�但不恰当地使用锁则可能产生死锁。死锁是�q�发�~�程中一个无法绕开的问题。只要在一个�Q务中使用了一个以上的锁，那么��存在死锁的风险�?br />死锁产生的直接原因非常简单，即两个线�E�在�怺��{�待�Ҏ��所执有的锁�?br />
2. 锁顺序死�?/span>
在死锁场景中�Q�最典型的就是锁��序死锁�Q�代码清�?��是一个很常见的示例�?br />
清单1
public class DeadLock {

    private Object leftLock = new Object();
    private Object rightLock = new Object();

    public void leftRight() {
        synchronized (leftLock) {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (rightLock) {
                System.out.println("leftRight");
            }
        }
    }

    public void rightLeft() {
        synchronized (rightLock) {
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (leftLock) {
                System.out.println("leftRight");
            }
        }
    }

    public static void main(String[] args) {
        final DeadLock deadLock = new DeadLock();

        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                deadLock.leftRight();
            }
        });

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                deadLock.rightLeft();
            }
        });

        t1.start();
        t2.start();
    }
}

3. Thread Dump
JDK提供了一�l�命令行工具�Q�其中就包括jstack。通过jstack可以获取当前正运行的Java�q�程的java stack和native stack信息。如果Java�q�程崩溃了，也可以通过它来获取core file中的java stack和native stack信息�Q�以方便我们定位问题�?br />��Z��能够使用jstack去输出目标Java�q�程的thread dump�Q�首先必��要弄清楚在执行清单1的程序时�Q�该�E�序的进�E�号。JDK提供的另一个命令行工具jps可以获取�pȝ��中所有Java�q�程的相关信息�?br />在命令行�H�口中执行命�?em>jps�Q�即可以得到清单2所�C�的�l�果
清单2
C:\Documents and Settings\Administrator>jps
2848
4552 DeadLock
5256 Jps
其中4552��是在笔者机器上执行�E�序DeadLock时所生成Java�q�程的进�E�号�?br />然后再执行命�?em>jstack 4552�Q�在�W�者的机器上就会得到清�?所�C�的�l�果
清单3
C:\Documents and Settings\Administrator>jstack 4552
2013-12-29 18:45:41
Full thread dump Java HotSpot(TM) Client VM (23.25-b01 mixed mode, sharing):

"DestroyJavaVM" prio=6 tid=0x00878800 nid=0xd00 waiting on condition [0x00000000]
   java.lang.Thread.State: RUNNABLE

"Thread-1" prio=6 tid=0x02b56c00 nid=0x14ec waiting for monitor entry [0x02fdf000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at concurrency.deadlock.DeadLock.rightLeft(DeadLock.java:33)
        - waiting to lock <0x22be6598> (a java.lang.Object)
        - locked <0x22be65a0> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$2.run(DeadLock.java:53)
        at java.lang.Thread.run(Thread.java:724)

"Thread-0" prio=6 tid=0x02b55c00 nid=0x354 waiting for monitor entry [0x02f8f000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at concurrency.deadlock.DeadLock.leftRight(DeadLock.java:19)
        - waiting to lock <0x22be65a0> (a java.lang.Object)
        - locked <0x22be6598> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$1.run(DeadLock.java:45)
        at java.lang.Thread.run(Thread.java:724)

"Service Thread" daemon prio=6 tid=0x02b34800 nid=0x133c runnable [0x00000000]
   java.lang.Thread.State: RUNNABLE

"C1 CompilerThread0" daemon prio=10 tid=0x02b13800 nid=0x10fc waiting on condition [0x00000000]
   java.lang.Thread.State: RUNNABLE

"Attach Listener" daemon prio=10 tid=0x02b11c00 nid=0x1424 waiting on condition [0x00000000]
   java.lang.Thread.State: RUNNABLE

"Signal Dispatcher" daemon prio=10 tid=0x02b10800 nid=0x1100 runnable [0x00000000]
   java.lang.Thread.State: RUNNABLE

"Finalizer" daemon prio=8 tid=0x02af4c00 nid=0x1238 in Object.wait() [0x02daf000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x22b60fb8> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:135)
        - locked <0x22b60fb8> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:151)
        at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:189)

"Reference Handler" daemon prio=10 tid=0x02af0000 nid=0x12e8 in Object.wait() [0x02d5f000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x22b60da0> (a java.lang.ref.Reference$Lock)
        at java.lang.Object.wait(Object.java:503)
        at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:133)
        - locked <0x22b60da0> (a java.lang.ref.Reference$Lock)

"VM Thread" prio=10 tid=0x02aee400 nid=0x129c runnable

"VM Periodic Task Thread" prio=10 tid=0x02b48000 nid=0x89c waiting on condition

JNI global references: 117

Found one Java-level deadlock:
=============================
"Thread-1":
  waiting to lock monitor 0x02af4a3c (object 0x22be6598, a java.lang.Object),
  which is held by "Thread-0"
"Thread-0":
  waiting to lock monitor 0x02af310c (object 0x22be65a0, a java.lang.Object),
  which is held by "Thread-1"

Java stack information for the threads listed above:
===================================================
"Thread-1":
        at concurrency.deadlock.DeadLock.rightLeft(DeadLock.java:33)
        - waiting to lock <0x22be6598> (a java.lang.Object)
        - locked <0x22be65a0> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$2.run(DeadLock.java:53)
        at java.lang.Thread.run(Thread.java:724)
"Thread-0":
        at concurrency.deadlock.DeadLock.leftRight(DeadLock.java:19)
        - waiting to lock <0x22be65a0> (a java.lang.Object)
        - locked <0x22be6598> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$1.run(DeadLock.java:45)
        at java.lang.Thread.run(Thread.java:724)

Found 1 deadlock.
在上�q�输��Z��Q�我们可以很明确地看��C��个死�?br />
"Thread-1":
  waiting to lock monitor 0x02af4a3c (object 0x22be6598, a java.lang.Object),
  which is held by "Thread-0"
"Thread-0":
  waiting to lock monitor 0x02af310c (object 0x22be65a0, a java.lang.Object),
  which is held by "Thread-1"
�q�且它还标明了程序是在哪个地�Ҏ��发现了上�q�死�?br />
"Thread-1":
        at concurrency.deadlock.DeadLock.rightLeft(DeadLock.java:33)
        - waiting to lock <0x22be6598> (a java.lang.Object)
        - locked <0x22be65a0> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$2.run(DeadLock.java:53)
        at java.lang.Thread.run(Thread.java:724)
"Thread-0":
        at concurrency.deadlock.DeadLock.leftRight(DeadLock.java:19)
        - waiting to lock <0x22be65a0> (a java.lang.Object)
        - locked <0x22be6598> (a java.lang.Object)
        at concurrency.deadlock.DeadLock$1.run(DeadLock.java:45)
        at java.lang.Thread.run(Thread.java:724)

4. ��结
死锁产生的直接原因非常简单，即两个线�E�在�怺��{�待�Ҏ��所执有的锁。锁��序死锁是其中最�l�典的场景，此外�q�有动态的锁顺序死锁。虽然表现�Ş式有所不同�Q�但本质上都是两个线�E�在以不同的��序来获取相同锁�Ӟ��发生了死锁问题�?br />使用thread dump可以帮助我们分析死锁产生的原因。除了直接��用jstack命��o来获取thread dump输出以外�Q�JDK�q�提供了jvisualvm工具�Q�它能以可视化的方式展示Java�E�序的进�E�号�q�导出thread dump�?/div>

John Jiang 2013-12-29 20:19 发表评论

Java Concurrent Animated(�?

John Jiang — Sat, 07 Dec 2013 09:45:00 GMT

Java Concurrent Animated
    在最��C��期的Java Magazine中有一��访谈，介绍了一个学习Java�q�发�~�程的动��d��?a >Java Concurrent Animated。该应用以十分直观的方式展示了Java�q�发工具包中的每一个重要组�Ӟ��降低了学习Java�q�发�~�程的难度�?2013.12.07最后更�?

Java Magazine�Q�有多少人已�l�试用过了你的Java Concurrent Animated应用�Q?/span>
Grazi�Q�该应用是在2009�q?月被引入的，从那时算��P��已经有了大约20000的下载量。但考虑到已有约一千万的Java开发者，�q�个下蝲量才只是开始。按国家区分�Q�下载最多的分别是美�?23%)�Q�印�?14)和中�?7%)�?/span>
    你可以下载一个可以执行的JAR文�g�Q�然后仅需双击它就可以�q�行了。该应用是由菜单驱动的，或者也可以使用向上或向下键在不同的囑փ�和动��M��间进行导航。它能运行在诸如Windows�Q�Mac�Q�Linux�{�等所有的�q�_��上。它要求安装Java SE 6或更高的版本�?/span>

Java Magazine�Q�对�q�个应用最典型的反馈是什么？
Grazi�Q�大家告诉我�q�个工具很好用。许多�h��实�Ҏ��感到兴奋�Q�尤其是那些正试囑֐�团队教授合适�ƈ发技术的老师与领��g��。Java是最早在核心�c�d��中引入�ƈ发的语言之一。在当时�Q�这是一个很强大的特性，但我们很快就发现一个非�怼��U�的程序员与会写出很糟�p�的�q�发代码。进行恰当的�q�发�~�程是一件困隄��x��不可能的事情�Q�但是如何�h们能�׃��旉��ȝ��解一些现有的框架�Q�那么在�q�行�q�发�~�码时所产生潜在错误��׃��变得极少�?/span>
    例如�Q�去看看Java内存模型。开发者经常忽视Java内存模型�Q�而像个幸��的�ȝ��一样在�~�码�Q�那么他们的�E�序会不太正常，因�ؓJava虚拟�?JVM)和服务器可能无法利用到由Java内存模型所提供的优化。由于内核在速度与数量上都有了增长，厂商们期望能够高效地利用到这些内核，然而由于错误的�q�发��理�Q�本来如期运行的�E�序却开始遇��C��一些零星的错误�?/span>

Java Magazine�Q�你是说�Q�这个应用会以我们所虚构的方式去使开发者们能够更快且直观地掌握Java�q�发的原理与实践�Q?/span>
Grazi�Q�那是达到这一目的一个有��的途径。你知道的，Java Concurrent Animated�q�不是一个Flash动画。它是一�l�可交互的Java�E�序�Q�也卻I��每个动画都是真地在��用它所要演�C�的�q�发�l��g。在屏幕的右�Ҏ��一个展�C�Z��码片断的面板�Q�由于动�ȝ��q�行�Q�它会动态地高亮昄��及恢复正在执行的代码�?/span>
    让你�l�你一个例子，�q�个例子发生在ReadWriteLock�q�个动画中。ReadWriteLock用于��保数据的一致性。它允许不受数量限制的线�E�去获取读锁�Q��ƈ能�ƈ发地对这个锁�q�行操作。但是，写线�E�在获取�q�个锁之前只能等待所有的�ȝ��E�执行结束。一旦一个写�U�程获得了这个锁�Q�那么其它的�ȝ��E�或写线�E�将无法获取它�?/span>
    假设一个写�U�程正在�{�待正在执行中的�ȝ��E�去释放�q�个读锁�Q�但�H�然一个新的读�U�程跑过来了。那么谁应该获得�q�个锁会比较好呢�Q�这个新的读�U�程应该跑到写线�E�前面去吗？毕竟�Q�如果其它的�ȝ��E�已�l�获得了�q�个锁，那么新来的读�U�程��Z��么要�ȝ��一个尚在等待中的写�U�程呢？而这实际上这正是Java 5所�q�的事儿。但某次我在Java 6上运行这个动��L��Q�我注意到行为发生了改变。即�Q�随后而来的读�U�程在获取到�q�个锁之前可能要�{�待所有的写线�E�先释放锁�?/span>
    我认��个新的行为是一个BUG�Q�且向�ƈ发专家Heinz Kabutz博士提及了此事。博士解释道�Q�这不是一个错误，而一个特性。如果允许新到的�ȝ��E�蟩到正处于�{�待中的写线�E�的前面去，�q�就存在产生�U�程饥饿条�g的高风险。因为，存在一�U�很大的可能性，可能没有��M��写线�E�能获得�q�个锁，它们��永�q�等待着。这��是一个如何��用动��d��警示依赖于JVM�q�行时版本的�U�程行�ؓ的例子�?/span>

Java Magazine�Q�以动画教程的�Ş式来展示�Ҏ��|��在Java�q�发�~�程中有何与众不同吗�Q?/span>
Grazi�Q�Miller定律教会我们�Q�我们的大脑在某一时刻能处理的思维的数量是有限的。�h�c�d��脑們֐�于进行顺序的思维处理�Q�那么即便我们能够克服��n体上的束�~�，�q�能够去正确地进行理解，在以后也很难�q�回臛_��去重新构造前面的思维处理。可以肯定地是，如果另一个开发者在以后能深入对其进行研�IӞ��那么仍然非常难以从原有的思维成果中再�ơ捕捉到认知轨迹。这��L��话，脆弱的代码就会很�H�然��C��能正常工作了�?/span>
    通过使用框架�Q�我们不仅将�q�发�~�程委托�l�了创徏和维护该框架的聪明开发者们�Q�而且�q��ؓ沟通设计时引入了一个词典。所以，我可以说�Q?#8220;下面的代码会当作CyclicBarrier��L��?#8221;�Q�而�h们会明白那是什么意思。通过为java.util.concurrent中的所有组仉��引入一个可交互化的动画应用�Q�开发者们点着鼠标��p��很方便地��他们所探究的功能进行可视化�Q��理解�q�些��法变得真心��单了�?/span>

Java Magazine�Q�你当时正在研究某些直觉�Q�这些直觉可以帮助更方便地学习�ƈ发编�E�。从开发者的反馈来看�Q�这些直觉看��h��是有效的�?/span>
Grazi�Q�是的。例如，我前面解释的ReadWriteLock基本功能。读者们可能理解了，也可能没有。现在让我们看看�q�个与其有关的动画，如图�?所�C��?/span>

    �l�色�U�程是读�U�程�Q�最上面的白色线�E?带着菱�Ş��头)是一个写�U�程�Q�它下面的白色线�E�是一个新的读�U�程�Q�该�U�程在获取锁之前必须要等待所有的�ȝ��E�与写线�E�执行完毕。如果你点击按钮�q�观看这些动画，会比通过��览�J�冗的解释性文字去�q�行理解要简单得多了�?/span>

Java Magazine�Q�Heinz Kabutz评论道，Java被构建成能够一�ơ性做许多事情�Q�而这正与�q�发完全相关。你的学习系�l�是如何提高�E�序员的技能，以便他们能降低�ƈ发错误的风险�?/span>
Grazi�Q�经常地�Q�当我要努力克服一个�ƈ发问题时�Q�我知道解决�Ҏ��存在于某个设计模式中，但是哪一个呢�Q�在开发者探��M��个正��解��x��案时�Q�Java Concurrent Animated��Z��们提供了一个所有方案的目录�Q�在�Ȁ发出正确�Ҏ��的过�E�中�Q�它扮演着向导的角艌Ӏ?/span>

Java Magazine�Q�当你管理的团队正在使用Java�q�发�Q��ƈ且你和你的团队都��x��好地�ȝ��解Java�q�发�Q�Java Concurrent Animated有着它的出发炏V��是什么导致你使用动画呢，能描�q�C��q�个�q�程吗？
Grazi�Q�我的培训是针对投资部门的服务器端Java应用�Q�在那里�Q��ƈ发是一个通常都会受到��x��的问题。交易员们要求�g�q�要低，�q�样可以��保他们在这个需要于一毫秒�H�口旉��内捕捉交易机会的比赛中不会成为失败者。批量处理也要求快速完成，�{�等。所以我开始看到那些可怕的只写(write-only)�l��g�Q�这些组件��Z��在�ƈ发编�E�挣扎着。我自己也��n处其中�?/span>
    某天下午�Q�我正坐在机场内�Q�将要前往芝加哥�ؓ我的团队做一个关于�ƈ发的讲演。我正对讲演的PPT�q�行最后的处理�Q�那�l��灯片着重演�C�Z��每一个重要的�l��g。�ؓ了引导我��览java.util.concurrent中每个�ƈ发组件的状态，我写了一些状态机�Q�它们展�C�Z��一些供我参考用的简单文本消息。在之前的生涯中�Q�我曑֜�一家互联网创业公司中开发交互式的游戏，所以我懂得许多与动�ȝ��关的知识。这使我惛_��可以��PPT替换成一�l�交互式的动��d��用，那会更�ؓ直观�?/span>
    在等飞机的过�E�中�Q�我写了一个初步的动画引擎�Q�然后在我的状态机中调用了�q�个引擎。到了第二天早晨�Q�我已经有一个可用的原型�E�序。多�q�来�Q�我一直致力于�q�个框架�Q��ƈ且吸引了其他专家的徏议。我传递过一份早期版本给Brian Goetz�Q��o人惊讶的是，他�ؓ每个动画�E�序都给��Z��。我��他的所有徏议到吸收��C��该框架中。在我的�W�一�ơJavaOne讲演中，Kirk Pepperdine加入了进来。他��为动��d��用在真正的PPT中加入描�q�ͼ�以便讲演者能��C��正在讨论的内宏V��随后我加上那些描述�Q�这��实非常有用--不只是对讲演者有用，对于�l�端用户也很有用。Heinz Kabutz也加入了那场讲演�Q��ƈ��修改某些动画�Q�以使它们更为直观�?/span>
    在另一��演中�Q�一个很有激情的软�g咨询师Oliver Zeigermann指出�Q�很昄��~�少了针对ConcurrentHashMap的动甅R��我问他是否有兴��A献这个动画，随后他添加了那个很有价值的动画�E�序�?/span>

Java Magazine�Q�你能带着我们�q�一遍Java�q�发工具包中的类吗？�q�能否解释一下这些动�ȝ��序是如何使开发者们更易于深入理解这些类�Q?/span>
Grazi�Q�好的，但在没有动画�E�序的情况下��实很难办到。让我们看看CyclicBarrier�Q�它有两个重要的状态，如图2和图3所�C�，它们展示了一个障��和四个成员。在�?中，我们可以看到有三个成员已�l�到了，所以它们被��L��l�箋前进。图3展示了，一旦第四个成员也到达了�Q�每个成员又可以向前��C��?/span>

    �q�就形象地诠释了障碍的概念，亦即�Q�在所有成员到��N��点之前�Q�每个成员必��ȝ��待。随着�q�发�l��g复杂度的增加--例如Fork/Join的动画，以及那些演示原生的wait和notify机制的动�?-使用动画�E�序的好处就更不肖说了�?/span>

Java Magazine�Q�谈谈在创徏�q�些动画�E�序的过�E�中所遇到的一些挑战�?/span>
Grazi�Q�有一些挑战。开始时�Q�线�E�被表示成箭头。对于多数�ƈ发组�Ӟ��q�种表示法是有效的。后来我们必��L��供一个可视化�Ҏ��Q�不仅要表示�U�程�Q�还要表�C�BlockingQueue中的对象。所以，我不得不引入一个称之�ؓ"�_��c�d��(sprite-type)"的概念，然后我们有了一个箭头型的精�늱�型和一个新�?对象"型的�_��c�d��。后来，ConcurrentHashMap和AtomicInteger又需要新的精�늱�型，因�ؓ我们试图要对他们的计��与交换行�ؓ�q�行可视化�?/span>
    后面又来了Fork/Join�Q�新的挑战就是如何去表现那些完全不同于现有框架所表现的可视化部�g。还有一个挑战，即Fork/Join动画需要解决一个实际的问题�Q�但�q�个动画应该解决一个什么样的问题呢�Q?/span>
    开始时�Q�我让这个动�ȝ��序去求Fibonacci数列�Q�但却行不通。我在这个问题上�U�结了两天时��_��直到我认识到Fibonacci数列(Fn+1=Fn+Fn-1)无法高效地�ƈ行化�Q�因为每个值都依赖于它前面的倹{��所以，无论你如何试囑֯�其实施�ƈ行化�Q�它天生��是一个顺序化的计��。所以我换成了另一个问�?-查找数组中的最大元素，�q�样��好了。在�q�个动画中，你可以很�_��地看到如何��用一个随机的数列去解册��个问�?如图4所�C?�?/span>

Java Magazine�Q�你都在哪里讲演�q�这些动�ȝ��序？
Grazi�Q�在JavaOne中讲演过几次�Q�在其它的许多会议，如奥斯陆中的JavaZone�Q�苏黎世的Jazoon�Q�纽�U�的QCon�Q�以及许多SIG(特别兴趣�l?和JUG(Java用户�l?中也都讲演过。我喜欢讲演�Q�我也喜�Ƣ周�怸�界，而Java Concurrent Animated为我提供了一个极好的��Z��d��q�两件事情。它总能获得极高的评仗��?/span>
    Java Concurrent Animated的讲演提供了一�U�意识，�q�且它们也向出席的开发者们展示了下载这一框架的�h��|��而且它还展示了，如果你拥有了框架和灵感启�q�，学习�q�发�~�程会是多么的容易�?/span>

John Jiang 2013-12-07 17:45 发表评论

Java�q�发基础实践--分而治�?�?

John Jiang — Wed, 23 Oct 2013 15:27:00 GMT
     摘要: Java�q�发基础实践--分而治之本�p�d��的第三篇文章��以实现一个极��单的查找最大数的�Q务�ؓ例，分别�l�出了四个版本：1.��序执行�Q?.��Z��传统的Thread.join()�Q?.��Z��q�发工具包的Future�Q?.��Z��JDK 7引入的Fork/Join框架�?2013.10.25最后更�?    分而治�?Divide-and-Conquer)是解军_��杂问题的常用�Ҏ��。在�q�发...  阅读全文

John Jiang 2013-10-23 23:27 发表评论

Java�q�发基础实践--退��Z�Q务II(�?

John Jiang — Mon, 07 Oct 2013 08:55:00 GMT

Java�q�发基础实践--退��Z�Q务II
�?a href="http://www.dentisthealthcenter.com/jiangshachina/category/53896.html">本系�?/a>�?a href="http://www.dentisthealthcenter.com/jiangshachina/archive/2013/09/21/404269.html">上一��?/a>中所�q�的退出�ƈ发�Q务的方式都是��Z��JDK 5之前的API�Q�本文将介绍使用由JDK 5引入的�ƈ发工具包中的API来退��Z�Q务�?2013.10.08最后更�?

    在本�p�d��的前一��中讲述了三�U�退出�ƈ发�Q务的方式--停止�U�程�Q�可取消的�Q务；中断�Q�但都是��Z��JDK 5之前的API。本��将介绍由JDK 5引入的java.concurrent包中的Future来取消�Q务的执行�?br />
1. Future模式
    Future是�ƈ发编�E�中的一�U�常见设计模式，它相当于是Proxy模式与Thread-Per-Message模式的结合。即�Q�每�ơ都创徏一个单独的�U�程��L��行一个耗时的�Q务，�q�且创徏一个Future对象��L��有实际的��d��对象�Q�在��来需要的时候再去获取实际�Q务的执行�l�果�?br />依然先创��Z��个用于扫描文件的��d��FileScannerTask�Q�如代码清单1所�C�，
清单1
public class FileScannerTask implements Runnable {

    private File root = null;

    private ArrayList<String> filePaths = new ArrayList<String>();

    public FileScannerTask(File root) {
        if (root == null || !root.exists() || !root.isDirectory()) {
            throw new IllegalArgumentException("root must be directory");
        }

        this.root = root;
    }

    @Override
    public void run() {
        travleFiles(root);
    }

    private void travleFiles(File parent) {
        String filePath = parent.getAbsolutePath();
        filePaths.add(filePath);

        if (parent.isDirectory()) {
            File[] children = parent.listFiles();
            if (children != null) {
                for (File child : children) {
                    travleFiles(child);
                }
            }
        }
    }

    public List<String> getFilePaths() {
        return (List<String>) filePaths.clone();
    }
}
此处的文件扫描�Q务，提供了一个getFilePaths()�Ҏ��以允讔R��旉��可以取出当前已扫描过的文件的路径(相当于一个�Q务快�?。然后，创徏一个针对该��d��的Future�c�，如代码清�?所�C�，
清单2
public class FileScannerFuture {

    private FileScannerTask task = null;

    public FileScannerFuture(FileScannerTask task) {
        new Thread(task).start();
        this.task = task;
    }

    public List<String> getResult() {
        return task.getFilePaths();
    }
}
FileScannerFuture持有FileScannerTask的引用，�q�创��Z��个独立的�U�程来执行该��d��。在��d��的执行过�E�中�Q�应用程序可以在"未来"的某个时��d��获取一个�Q务的快照�Q�如代码清单3所�C�，
清单3
public static void main(String[] args) throws Exception {
    FileScannerFuture future = new FileScannerFuture(new FileScannerTask(new File("C:")));

    TimeUnit.SECONDS.sleep(1);
    List<String> filePaths1 = future.getResult();
    System.out.println(filePaths1.size());

    TimeUnit.SECONDS.sleep(1);
    List<String> filePaths2 = future.getResult();
    System.out.println(filePaths2.size());
}

2. 使用�q�发工具包中的Future实现
    前面所展示的Future实现十分的简陋，没有实际应用的意义。��用FileScannerFuture�Q�应用程序在获取filePaths�Ӟ��无法得知其获取的是否为最�l�结果，��x��法判断FileScannerTask是否已经完成。而且�Q�也不能在必要时停止FileScannerTask的执行。毫无疑问，由JDK 5引入的�ƈ发工具包肯定会提供此�c�d��用工��P��如FutureTask。�ؓ了��用�ƈ发工具包中的Future�Q�需要修改前�q�的FileScannerTask实现�Q�让其实现Callable接口�Q�如代码清单4所�C�，
清单4
public class FileScannerTask implements Callable<List<String>> {

    private File root = null;

    private List<String> filePaths = new ArrayList<String>();

    public FileScannerTask(File root) {
        if (root == null || !root.exists() || !root.isDirectory()) {
            throw new IllegalArgumentException("root must be directory");
        }

        this.root = root;
    }

    @Override
    public List<String> call() {
        travleFiles(root);
        return filePaths;
    }

    private void travleFiles(File parent) {
        String filePath = parent.getAbsolutePath();
        filePaths.add(filePath);

        if (parent.isDirectory()) {
            File[] children = parent.listFiles();
            if (children != null) {
                for (File child : children) {
                    travleFiles(child);
                }
            }
        }
    }

    public List<String> getFilePaths() {
        return (List<String>) filePaths.clone();
    }
}
应用�E�序也要相应的修�Ҏ��如代码清�?所�C�，使用ExecutorService来提交�Q务，�q�创��Z��个Future/FutureTask实例�?br />
清单5
public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    Future<List<String>> future = executorService.submit(new FileScannerTask(new File("C:")));

    try {
        List<String> filePaths = future.get();
        System.out.println(filePaths.size());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }

    executorService.shutdown();
}
此处��是调用Future.get()�Ҏ��来获取�Q务的执行�l�果�Q�如果�Q务没有执行完毕，那么该方法将会被��d��。该Future实现的好处就是，正常情况下，只有在�Q务执行完毕之后才能获取其�l�果�Q�以保证该结果是最�l�执行结果�?br />
3. 使用Future取消��d��
    Future除了定义有可获取执行�l�果的get�Ҏ��(get()以及get(long timeout, TimeUnit unit))�Q�还定义了三个方法：cancel()�Q�isCancelled()以及isDone()�Q�用于取消�Q务，以及判定��d��是否已被取消、已执行完毕。如代码清单6所�C�，
清单6
public interface Future<V> {

    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();

}
其中�Q�cancel()�Ҏ��中的boolean参数若�ؓtrue�Q�表�C�在取消该�Q务时�Q�若执行该�Q务的�U�程仍在�q�行中，则对其进行中断。如代码清单7所�C�，若�Q务执行超时了�Q�那么就取消它�?br />
清单7
public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    Future<List<String>> future = executorService.submit(new FileScannerTask(new File("C:")));

    try {
        List<String> filePaths = future.get(1, TimeUnit.SECONDS);
        System.out.println(filePaths.size());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    } catch (TimeoutException e) {
        e.printStackTrace();
    } finally {
        future.cancel(true);
    }

    executorService.shutdown();
}
在实际应用中�Q�取消�Q务的原由肯定不仅仅只是超时这么简单，�q�可能是�׃��接受��C��用户的指令。此�Ӟ��则可能会从另一个独立线�E�去取消该�Q务。除了取消�Q务之外，有时�q�需要取��Z�Q务中已经生成的部分结果。但��Z��能够响应��d��的退出，首先需要修改FileScannerTask�Q��得当��d��被取�?中断)�Ӟ��d��能够真正的快速停止�ƈ�q�回�Q�如代码清单8所�C�，
清单8
public class FileScannerTask implements Callable<List<String>> {



    private void travleFiles(File parent) {
        if (Thread.currentThread().isInterrupted()) {
            return;
        }

        String filePath = parent.getAbsolutePath();
        filePaths.add(filePath);

        if (parent.isDirectory()) {
            File[] children = parent.listFiles();
            if (children != null) {
                for (File child : children) {
                    travleFiles(child);
                }
            }
        }
    }


}
相应��C��改应用程序的代码�Q�如代码清单9所�C�，
清单9
public static void main(String[] args) {
    ExecutorService executorService = Executors.newCachedThreadPool();
    FileScannerTask task = new FileScannerTask(new File("C:"));
    final Future<List<String>> future = executorService.submit(task);

    new Thread(new Runnable() {

        @Override
        public void run() {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            future.cancel(true);
        }
    }).start();

    try {
        List<String> filePaths = future.get();
        System.out.println(filePaths.size());
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    } catch (CancellationException e) {
        List<String> filePaths = task.getFilePaths();
        System.out.println("Partly result: " + filePaths.size());
    }

    executorService.shutdown();
}
�׃��可知�Q�此处��用Future.cancel(true)的本质依然是利用了线�E�的中断机制�?br />
4. ��结
    使用Future可以在�Q务启动之后的特定时机再去获取��d��的执行结果。由JDK 5引入的�ƈ发工具包中提供的Future实现不仅可以获取��d��的执行结果，�q�可以用于取消�Q务的执行�?/div>

John Jiang 2013-10-07 16:55 发表评论

Java�q�发基础实践--退��Z�Q务I(�?

John Jiang — Sat, 21 Sep 2013 11:11:00 GMT

Java�q�发基础实践--退��Z�Q务I
计划写一�?Java�q�发基础实践"�p�d��Q�算作本人对Java�q�发学习与实�늚��单�ȝ��。本文是该系列的�W�一��，介绍了退出�ƈ发�Q务的最��单方法�?2013.09.25最后更�?

在一个�ƈ发�Q务被启动之后�Q�不要期望它��L��会执行完成。由于时间限�Ӟ��资源限制�Q�用��h��作，甚至是�Q务中的异�?��其是运行时异常)�Q?..都可能造成��d��不能执行完成。如何恰当地退��Z�Q务是一个很常见的问题，而且实现�Ҏ��也不一而��?/span>

1. ��d��
创徏一个�ƈ发�Q务，递归地获取指定目录下的所有子目录与文件的�l�对路径�Q�最后再��这些�\径信息保存到一个文件中�Q�如代码清单1所�C�：
清单1
public class FileScanner implements Runnable {

    private File root = null;

    private List<String> filePaths = new ArrayList<String>();

    public FileScanner1(File root) {
        if (root == null || !root.exists() || !root.isDirectory()) {
            throw new IllegalArgumentException("root must be legal directory");
        }

        this.root = root;
    }

    @Override
    public void run() {
        travleFiles(root);
        try {
            saveFilePaths();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void travleFiles(File parent) {
        String filePath = parent.getAbsolutePath();
        filePaths.add(filePath);

        if (parent.isDirectory()) {
            File[] children = parent.listFiles();
            for (File child : children) {
                travleFiles(child);
            }
        }
    }

    private void saveFilePaths() throws IOException {
        FileWriter fos = new FileWriter(new File(root.getAbsoluteFile()
                + File.separator + "filePaths.out"));
        for (String filePath : filePaths) {
            fos.write(filePath + "\n");
        }
        fos.close();
    }
}

2. 停止�U�程
有一个很直接�Q�也很干脆的方式来停止线�E�，��是调用Thread.stop()�Ҏ��Q�如代码清单2所�C�：
清单2
public static void main(String[] args) throws Exception {
    FileScanner task = new FileScanner(new File("C:"));
    Thread taskThread = new Thread(task);
    taskThread.start();

    TimeUnit.SECONDS.sleep(1);
    taskThread.stop();
}
但是�Q�地球�h都知道Thread.stop()在很久很久之前就不推荐��用了。根�?a >官方文��的介�l�，该方法存在着固有的不安全性。当停止�U�程�Ӟ��会释放该线�E�所占有的全部监视锁�Q�这��׃��造成受这些锁保护的对象的不一致性。在执行清单2的应用程序时�Q�它的运行结果是不确定的。它可能会输��Z��个文�Ӟ��其中包含部分的被扫描�q�的目录和文件。但它也很有可能什么也不输出，因�ؓ在执行FileWriter.write()的过�E�中�Q�可能由于线�E�停止而造成了I/O异常�Q��得最�l�无法得到输出文件�?/span>

3. 可取消的��d��
另外一�U�十分常见的途径是，在设计之初，我们��׃��d��是可被取消的。一般地�Q�就是提供一个取消标志或讑֮�一个取消条�Ӟ��一旦�Q务遇到该标志或满��了取消条�g�Q�就会结束�Q务的执行。如代码清单3所�C�：
清单3
public class FileScanner implements Runnable {

    private File root = null;

    private List<String> filePaths = new ArrayList<String>();

    private boolean cancel = false;

    public FileScanner(File root) {

    }

    @Override
    public void run() {

    }

    private void travleFiles(File parent) {
        if (cancel) {
            return;
        }

        String filePath = parent.getAbsolutePath();
        filePaths.add(filePath);

        if (parent.isDirectory()) {
            File[] children = parent.listFiles();
            for (File child : children) {
                travleFiles(child);
            }
        }
    }

    private void saveFilePaths() throws IOException {

    }

    public void cancel() {
        cancel = true;
    }
}
新的FileScanner实现提供一个cancel标志�Q�travleFiles()会遍历新的文件之前检��该标志�Q�若该标志�ؓtrue�Q�则会立卌��回。代码清�?是��用新��d��的应用程序�?/span>
清单4
public static void main(String[] args) throws Exception {
    FileScanner task = new FileScanner(new File("C:"));
    Thread taskThread = new Thread(task);
    taskThread.start();

    TimeUnit.SECONDS.sleep(3);
    task.cancel();
}
但有些时候��用可取消的�Q务，�q�不能快速地退��Z�Q务。因��Z�Q务在��取消标志之前，可能正处于等待状态，甚至可能被阻塞着。对清单2中的FileScanner�E�作修改�Q�让每次讉K��新的文�g之前先睡�?0�U�钟�Q�如代码清单5所�C�：
清单5
public class FileScanner implements Runnable {



    private void travleFiles(File parent) {
        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        if (cancel) {
            return;
        }


    }

    private void saveFilePaths() throws IOException {

    }

    public void cancel() {
        cancel = true;
    }
}
再执行清�?中的应用�E�序�Ӟ��可能发现��d��q�没有很快速的退出，而是又等待了大约7�U�钟才退出。如果在��查cancel标志之前要先获取某个受锁保护的资源，那么该�Q务就会被��d��Q��ƈ且无法确定何时能够退出。对于这�U�情况，��需要��用中断了�?/span>

4. 中断
中断是一�U�协作机�Ӟ��它�ƈ不会真正地停止一个线�E�，而只是提醒线�E�需要被中断�Q��ƈ��线�E�的中断状态设�|��ؓtrue。如果线�E�正在执行一些可抛出InterruptedException的方法，如Thread.sleep()�Q�Thread.join()和Object.wait()�Q�那么当�U�程被中断时�Q�上�q�方法就会抛出InterruptedException�Q��ƈ且中断状态会被重新设�|��ؓfalse。�Q务程序只要恰当处理该异常�Q�就可以正常地退��Z�Q务。对清单5再稍作修改，卻I��如果��d��在睡眠时遇上了InterruptedException�Q�那么就取消��d��。如代码清单6所�C�：
清单6
public class FileScanner implements Runnable {



    private void travleFiles(File parent) {
        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            cancel();
        }

        if (cancel) {
            return;
        }


    }


}
同时��清�?中的应用�E�序�Q�此时将调用Thread.interrupt()�Ҏ��M��断线�E�，如代码清�?所�C�：
清单7
public static void main(String[] args) throws Exception {
    FileScanner3 task = new FileScanner3(new File("C:"));
    Thread taskThread = new Thread(task);
    taskThread.start();

    TimeUnit.SECONDS.sleep(3);
    taskThread.interrupt();
}
或者更�q�一步，仅��用中断状态来控制�E�序的退出，而不再��用可取消的�Q�?卻I��删除cancel标志)�Q�将清单6中的FileScanner修改成如下：
清单8
public class FileScanner implements Runnable {



    private void travleFiles(File parent) {
        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        if (Thread.currentThread().isInterrupted()) {
            return;
        }


    }


}
再次执行清单7的应用程序后�Q�新的FileScanner也能��x��的退��Z��。值得注意的是�Q�因为当sleep()�Ҏ��抛出InterruptedException�Ӟ��该线�E�的中断状态将又会被设�|��ؓfalse�Q�所以必��要再次调用interrupt()�Ҏ��来保存中断状态，�q�样在后面才可以利用中断状态来判定是否需要返回travleFiles()�Ҏ��。当�Ӟ��对于此处的例子，在收到InterruptedException时也可以选择直接�q�回�Q�如代码清单9所�C�：
清单9
public class FileScanner implements Runnable {



    private void travleFiles(File parent) {
        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e) {
            return;
        }


    }


}

5 ��结
本文介绍了三�U�简单的退出�ƈ发�Q务的�Ҏ��Q�停止线�E�；使用可取消�Q务；使用中断。毫无疑问，停止�U�程是不可取的。��用可取消的�Q务时�Q�要避免��d��׃��被阻塞而无法及�Ӟ��甚至永远无法被取消。一般地�Q�恰当地使用中断是取消�Q务的首选方式�?/span>

John Jiang 2013-09-21 19:11 发表评论

��Z��喜欢在ThoughtWorks工作(�?

John Jiang — Thu, 22 Aug 2013 06:43:00 GMT

��Z��喜欢在ThoughtWorks工作
本文是ThoughtWorks首席�U�学家Martin Fowler接受InformIT采访时的访谈�?/a>�Q�谈��C��在ThoughtWorks工作的情况，对ThoughWorks感兴��的朋友们可以看看�?2013.08.23最后更�?

Martin Fowler分��n了他关于ThoughtWorks的看法，�q�是一家关注可持箋性以及经��和�C�会公正的��Y件开发公司。Martin谈到了他是如何开始了在ThoughtWorks的工作，他�ؓ什么会喜欢�q�家公司的文化，以及�Ҏ��的��Y件开发者的��?/span>

InformIT�Q?/strong>你是怎样得到�?a >ThoughtWorks的工作？
Martin Fowler�Q?/strong>围绕一个当时他们正从事的项目的域模型，他们让我做些咨询工作。我们进展的不错�Q�最后我��p��然而然地加入进来了。在此期��_��他们大步地�{向极限编�E�这一软�g开发风根{��约九个月后�Q�他们向我提供了一份offer。由于他们是我最喜欢的客��P��我就军_��加入他们�?/span>

InformIT�Q?/strong>你在那儿工作多长旉��了？
Martin Fowler�Q?/strong>12�q��?/span>

InformIT�Q?/strong>ThoughtWorks与其它公司有何不同？
Martin Fowler�Q?/strong>�Ҏ��上，�q�种不同要归�l��ؓ人。他们善于雇佣既聪明又乐于合作的人。特别是�Q�这里会更多��C��正直的态度��d��注�h。我发现�Q�相比于�q�去多年中共事过的大多数客户�Q�我更加信�Q我的同事。还有对完成高质量工作�ƈ期望做到更好的真挚热情，对于像我�q�样的作者，�q�是极好的素材�?/span>

InformIT�Q?/strong>对于在那儿工作，你最喜欢的是什么？
Martin Fowler�Q?/strong>ThoughtWorks有许多东西可�?a >��d��。只是困难之处在于，我要挑哪块儿去讲�q�呢�?/span>

InformIT�Q?/strong>工作在ThoughtWorks�Q�你最自豪的是什么？
Martin Fowler�Q?/strong>我最自豪的是�Q�我们从一家几百�h的美国公司成长�ؓ在世界范围内拥有两千人的公司�Q�而且原封不动��C��持了公司文化中的�_�N��。我不确定我在其中扮演了什么角�Ԍ��但这里一直是我喜�Ƣ工作的地方�Q��ƈ且公�怸�直在宣传我，使大家能有兴��与ThoughtWorks协作�Q�我�Ҏ��感到高兴�?/span>
��管如此�Q�我仍不能肯定这�U�情冉|��否要大大地归功于我。在与我本�h更明��相关的工作中，我必��d��_��我很高兴在过��d��q�中建立�?a >martinfowler.com。�ؓ了关注今后在改进�q�个站点时所做的事情�Q�该站点已成��Z��个丰富的资源和永恒的�q�题�?/span>
在更需要协作的工作前沿�Q�我��实很高兴地看到我的一些同事已�l�成��Z��内�D��重的"大嘴"。我不认为我在这其中有很大的作用--我给予的��M��帮助能够��L��地超�q�他们自�w�的努力--但这��实是我最惛_��的�A献�?/span>

InformIT�Q?/strong>��Z��么会有�h想着去ThoughtWorks工作�Q?/span>
Martin Fowler�Q?/strong>对于�l�验��的人，我想最大的吸引力是�Q�能在许多不同类型的��目中学会做好��Y件开发的能力。当�Ӟ��ThoughtWorks的项目�ƈ非完��，但我认�ؓ它们比绝大多数��Y仉��目要好得多。我听过很多ThoughtWorks前员工们谈到他们在公司工作的岁月中对于��Y件开发学��C��许多�?/span>
而在所有的原因当中�Q�旅行机会也是很重要的。如果你惌��上一大段旉��在世界上不同的地��行工作，例如在美国�h在印度工作，或巴西�h在中国工作，那么ThoughtWorks提供了大量的此类��Z��。这也与我们日益兛_��C�会正义的问题有养I��我认为对于许多有�l�验的�h来说�q�也是一个重要的因素�?/span>

InformIT�Q?/strong>对于一个刚刚开始在ThoughtWorks工作的新员工�Q�你有什么徏议吗�Q?/span>
Martin Fowler�Q?/strong>对于在ThoughtWorks工作的�h们，最沮��的事情之一��是我们不做职业规划�Q�这��׃��很容易危险地在项目间漂来漂去。对于有些�h来说�q�不是问题，但如果你惌��定一个职业方向，那么你必��d��自己��d��。这意味着大量的交际，��L��机遇�Q��ƈ�U�极推进。这不是一�U�直接的途径�Q�但在我成�ؓ独立咨询师之前，没有�q�种促进我前行的职业计划�Q�就会有相反的效果�?/span>

InformIT�Q?/strong>告诉我们一�?只会发生在ThoughtWorks"的故事�?/span>
Martin Fowler�Q?/span>我记得有�ơ被拉去讨论一个和BigCo相关的很有前景的��目。这�W�交易确实很大，在初始阶�D�就要耗费�U?0+�?�q�。但存在着一些对BigCo在道徯��录方面的担忧�Q�尤其是在发展中国家。在�q�一讨论中，�U��a的ThoughtWorks要义是，CFO��h��Ȁ昂地反对接下�q�笔高利润额的工作，而所有的高��领导们则們֐�着一位来自南方国家最�q�才受雇于ThoughtWorks的初�U�开发者，他描�q�C��BigCo的行径是怎样损害着他的国家�?/span>

John Jiang 2013-08-22 14:43 发表评论

Oracle OpenWorld 2013(上�v)(�?

John Jiang — Fri, 02 Aug 2013 03:50:00 GMT

Oracle OpenWorld 2013(上�v)
Oracle OpenWorld 2013(上�v)已经�l�束�Q�我全程参与了此�ơ技术大会。本文是我参会的所见、所闅R��所思与所感，有文�Q�有图，且无码�?2013.08.03最后更�?

Oracle OpenWorld 2013(Shanghai) lasted four days, and included over 300 keynotes, sessions and hands-on labs. 18000+ attendees, including company leaders, industries experts and developers, joined the event, which was said the biggest IT activity in Asia-Pacific area as never before.

Sessions
* Java strategy/technical keynote
Every JavaOne conference must has such keynote, which introduces and demonstrates the latest new JDK versions and features, and prospects upcoming JDK version and features. All parts of Java ecosystem, including JME, JSE, JEE and JavaFX, are involved in the keynote. I was deeply impressed by JavaFX demo by Jim Weaver. The Java champion played musical instruments with a JavaFX application; that's really cool. In this JavaOne, JavaFX has a separated track, and the technology is very highlighted by Oracle. The software giant expects JavaFX to enhance Java's performance on rich application. But outspokenly, it's difficult to take end users to install a JRE beforehand if they just want to run a desktop application.

* Why should I switch to Java SE 7?
JDK 6 has rested in peace(exactly, the version isn't completely frozen), and JDK 7 has been released for two years, and even JDK 8 will come next March. But do you migrate your JRE to Java 7? Strings in switch statements, diamond operator, try with resources, multi-catch statement, ... Do you like the compiler sugar? Anyway, the features could improve development productivity. But fork-join framework really touches my heart. Because of complete backward compatibility, you just need to run your application in the new platform, and the performance could be accelerated.

* The road to Lambda
Java has been being criticised for implementing modern language features, like closure. The argument around closure implementation has lasted for a long time. Finally, Lambda, the closure for Java, has been finished, and will be distributed with JDK 8. Lambda is regarded as the biggest change since Generics in Java 5. Function Programming (FP) is popular, and Java developers can utilise Lambda expression to apply FP. And JDK 8 extends Collection framework to take advantage of Lambda as powerful as possible. For example, currently we need an iterator or loop to iterate a Collection container, that's so-called external iteration. JDK 8 adds a new method forEach() for Collection interface, and we can iterate a Collection object via internal iteration, that means it's no need to care the iteration details by developers. In fact, it's impossible to debug the iterating process. And the process may apply fork-join if possible to improve performance. That sounds cool!

* Effective Scala
Dynamic programming languages are emerging, and more languages, such as Groovy, Scala and Clojure, can run on JVM, and JDK 7 introduced a new instruction "invokeDynamic" to support dynamic languages better. Therefore, I have to pay some attention to other JVM languages. The session "Effective Scala" was provided by TypeSafe, a company founded by Scala creators; Spring founder Rod Johnson joined the company as member of board of directors last year. The session simulated the style of Effective Java, and also introduced some best practices and coding regulations. Frankly, I don't know Scala syntax, like traits, totally, so I don't understand the lecture exactly. But I still obtained something new, like Cake pattern. Do you know the design pattern? I never hear it before this session, but the pattern is well-known in Scala world. It's time to learn another language, and I think Groovy is a good start-up due to it is closer to Java.

* Taobao GCIH
Taobao creates GCIH (GC Invisible Heap) based on Oracle VM Hotspot, and allows different VM to access a shared heap. In Taobao business scenario, the shared heap only stores read-only objects. All of the objects are initialized after the application is launched, and not be cleaned before the application shutdowns. Therefore, single VM can consume less memory, that means we can deploy more VMs in single machine. And GCIH cannot be accessed by GC so that reducing the garbage collection overhead.

* What do you mean, backwards compatibility?
10gen, the company behind MongoDB, presented the topic. Because old MongoDB driver isn't well designed, so it's difficult to understand and use the driver API. For example, the driver has a lot of find() methods, but how do I know which one is my want. According to the session, method chaining not only makes codes more readable, and the idiom benefits the backward compatibility as well. Generally, method chaining only handle one parameter at each invoking, and application codes don't care the sequence of invoking. In this case, it's no need to provide the methods with several arguments, and the methods are possible to be deprecated in later time due to their ambiguity. Of course, method chaining isn't designed for backward compatibility. And applying backward compatibility is still a hard job, because you don't know what would happen in the future. In fact, many and many APIs are deprecated in later JDK versions.

Appreciation Party
In the third evening, Oracle catered a small but exciting party to every attendee. Beer, snacks, professional band, beautiful girls, hot performances, ... were on the stage. All of performances were shown by Oracle employees, and we just rock!

I was on the scene
In OTN lounge, I communicated with Jim Weaver and his assistant about JavaFX and UI testing. In this event, my small dream, taking a photo with Java mascot -- Duke, came true ^_^ Additionally, don't forget iron man :-)

Event Organization
This is my sixth SunTechDays/OOW, and I must say that the conference was organized the best this time. Professional agenda, considerate attendee service, delicious dessert and drinking, all of them, except for lunch, must be delighted.

Finally, I must say the event is well worth participating; join it, and enjoy it :-)

John Jiang 2013-08-02 11:50 发表评论

世界一直在�?�?

John Jiang — Sun, 14 Jul 2013 03:15:00 GMT

世界一直在�?/span>
    最�q�有点儿�Ԍ��看了一些文章，有了一些感触，写成一��小文。��Y件世界真的变化很大，没有永恒的终�l�者。今天的�l�结者，明天可能��׃��被别人终�l�。道理大安��懂，但现实依然很�D�酷�?2013.07.29最后更�?

    This week, I read some articles about some API and tools that developers, especially Java guys, must know. Fortunately, I really know some of them, but unfortunately, I really miss something.

    Please let me introduce some cases at first:
    1. In our real projects, we only use JDK 6, but the version had been in End-Of-Life; we never touch JDK 7, but JDK 8 is upcoming. I don't know how much time we would spend on accepting Lambda expression. In fact, at present, a lot of Java developers cannot understand Generics exactly, however the syntax has been introduced for more than 8 years. Of course, Java Generics is a bit ambiguous, so it may be difficult to understand.
    2. Ant was ever the standard for building, and it still being used by many projects, even new ones. Maven was designed to terminate Ant due to the older cannot make life easy. Some conceptions of Maven, such as build life cycle, dependency management, default directory structure, are very advanced. But Maven dependency and transitive dependency management is nightmare, you have to include/exclude this or that. And extending Maven is also a hard job. I have real experience on both of them, I even wrote some popular preliminary blogs about Maven several years ago. But what I really don't know? I don't know Maven is becoming legacy, and worse, a new super star Gradle is on stage. Outspokenly, I never hear of the artifact before this week :-( Outstanding Spring framework is a very case about the trend. At beginning, obviously Spring is built by Ant, then the framework switched to Maven some years ago, but last year Spring migrated to Gradle.
    3. Google-Collections was well-known if you used it or not, and I know Guava however I never use the API. But what I really don't know? I don't know google-collections was closed several years ago, and even it was combined by Guava, which is a new rock star in Java ecosystem.

　　OH, something is born, and then grows, and then rests in peace. That's nature, and we have to face it, but why I don't know? Exactly, I have no idea.
　　World has been changing, and is changing faster as never before. How to keep us up-to-date with new fashion? I think the question may be asked by every "old" developer. After a long term career life, some of us may become veteran, but absolutely, it's impossible that everyone become expert, particularly the expert in underlying fields. We just be proficient in some programming languages, frameworks, APIs, or tools. So we must update our brains continuously.
　　Maybe the issue is one of the middle life crisis problems, good luck for you and me :-)

John Jiang 2013-07-14 11:15 发表评论

BlogJava-John Jiang

探烦HTTP/2: ���的状�?�?

探烦HTTP/2: HPACK协议����q?�?

探烦HTTP/2: 初试HTTP/2(�?

探烦HTTP/2: HTTP 2协议����q?�?

Play OpenJDK: 允许你的包名�?java."开�?�?

Play OpenJDK: 构徏你自��q��JDK(�?

利用Java SE 8���处理数据II(�?

利用Java SE 8���处理数�?I)(�?

2014�q?4月美国非农业��׃��情况报告(�?

Java 8的语�a�变化(�?

Java���的8个特�?�?

使用Gradle构徏Java Web应用(�?

Java�q�发基础实践--死锁(�?

Java Concurrent Animated(�?

Java�q�发基础实践--分而治�?�?

Java�q�发基础实践--退��Z�Q务II(�?

Java�q�发基础实践--退��Z�Q务I(�?

��Z��喜欢在ThoughtWorks工作(�?

Oracle OpenWorld 2013(上�v)(�?

世界一直在�?�?

探烦HTTP/2: ��的状�?�?

探烦HTTP/2: HPACK协议��q?�?

探烦HTTP/2: HTTP 2协议��q?�?

利用Java SE 8��处理数据II(�?

利用Java SE 8��处理数�?I)(�?

Java��的8个特�?�?