《Netty 权威指南》—— AIO创建的TimeClient源码分析

声明：本文是《Netty 权威指南》的样章，感谢博文视点授权并发编程网站发布样章，禁止以任何形式转载此文。

异步非阻塞IO版本的时间服务器服务端已经介绍完毕，下面我们继续看客户端的实现。

首先看下客户端主函数的实现，AIO时间服务器客户端  TimeClient：

01	public class TimeClient {

02

03

/**

04	* @param args

05

*/

06	public static void main(String[] args) {

07	int port = 8080;

08	if (args != null && args.length > 0) {

09

try {

10	port = Integer.valueOf(args[0]);

11	} catch (NumberFormatException e) {

12

// 采用默认值

13

}

14

}

15	new Thread(new AsyncTimeClientHandler("127.0.0.1", port),

16	"AIO-AsyncTimeClientHandler-001").start();

17

18

}

19

}

第15行我们通过一个独立的IO线程创建异步时间服务器客户端handler，在实际项目中，我们不需要独立的线程创建异步连接对象，因为底层都是通过JDK的系统回调实现的，在后面运行时间服务器程序的时候，我们会抓取线程调用堆栈给大家展示。继续看代码， AsyncTimeClientHandler的实现类源码如下：

001	public class AsyncTimeClientHandler implements

002	CompletionHandler<Void, AsyncTimeClientHandler>, Runnable {

003

004	private AsynchronousSocketChannel client;

005	private String host;

006	private int port;

007	private CountDownLatch latch;

008

009	public AsyncTimeClientHandler(String host, int port) {

010	this.host = host;

011	this.port = port;

012

try {

013	client = AsynchronousSocketChannel.open();

014	} catch (IOException e) {

015	e.printStackTrace();

016

}

017

}

018

019

@Override

020	public void run() {

021	latch = new CountDownLatch(1);

022	client.connect(new InetSocketAddress(host, port), this, this);

023

try {

024	latch.await();

025	} catch (InterruptedException e1) {

026	e1.printStackTrace();

027

}

028

try {

029	client.close();

030	} catch (IOException e) {

031	e.printStackTrace();

032

}

033

}

034

035

@Override

036	public void completed(Void result, AsyncTimeClientHandler attachment) {

037	byte[] req = "QUERY TIME ORDER".getBytes();

038	ByteBuffer writeBuffer = ByteBuffer.allocate(req.length);

039	writeBuffer.put(req);

040	writeBuffer.flip();

041	client.write(writeBuffer, writeBuffer,

042	new CompletionHandler<Integer, ByteBuffer>() {

043

@Override

044	public void completed(Integer result, ByteBuffer buffer) {

045	if (buffer.hasRemaining()) {

046	client.write(buffer, buffer, this);

047

} else {

048	ByteBuffer readBuffer = ByteBuffer.allocate(1024);

049	client.read(

050	readBuffer,

051	readBuffer,

052	new CompletionHandler<Integer, ByteBuffer>() {

053

@Override

054	public void completed(Integer result,

055	ByteBuffer buffer) {

056	buffer.flip();

057	byte[] bytes = new byte[buffer

058	.remaining()];

059	buffer.get(bytes);

060	String body;

061

try {

062	body = new String(bytes,

063

"UTF-8");

064	System.out.println("Now is : "

065

+ body);

066	latch.countDown();

067	} catch (UnsupportedEncodingException e) {

068	e.printStackTrace();

069

}

070

}

071

072

@Override

073	public void failed(Throwable exc,

074	ByteBuffer attachment) {

075

try {

076	client.close();

077	latch.countDown();

078	} catch (IOException e) {

079	// ingnore on close

080

}

081

}

082

});

083

}

084

}

085

086

@Override

087	public void failed(Throwable exc, ByteBuffer attachment) {

088

try {

089	client.close();

090	latch.countDown();

091	} catch (IOException e) {

092	// ingnore on close

093

}

094

}

095

});

096

}

097

098

@Override

099	public void failed(Throwable exc, AsyncTimeClientHandler attachment) {

100	exc.printStackTrace();

101

try {

102	client.close();

103	latch.countDown();

104	} catch (IOException e) {

105	e.printStackTrace();

106

}

107

}

108

}

由于在AsyncTimeClientHandler中大量使用了内部匿名类，所以代码看起来稍微有些复杂，下面我们就对主要代码进行详细解说。

9-17行是构造方法，首先通过AsynchronousSocketChannel的open方法创建一个新的AsynchronousSocketChannel对象。然后跳到第36行，创建CountDownLatch进行等待，防止异步操作没有执行完成线程就退出。第37行通过connect方法发起异步操作，它有两个参数，分别如下：

1)      A attachment : AsynchronousSocketChannel的附件，用于回调通知时作为入参被传递，调用者可以自定义；

2)      CompletionHandler<Void,? super A> handler：异步操作回调通知接口，由调用者实现。

在本例程中，我们的两个参数都使用AsyncTimeClientHandler类本身，因为它实现了CompletionHandler接口。

接下来我们看异步连接成功之后的方法回调completed方法，代码第39行，我们创建请求消息体，对其进行编码，然后拷贝到发送缓冲区writeBuffer中，调用AsynchronousSocketChannel的write方法进行异步写，与服务端类似，我们可以实现CompletionHandler<Integer, ByteBuffer>接口用于写操作完成后的回调，代码第45-47行，如果发送缓冲区中仍有尚未发送的字节，我们继续异步发送，如果已经发送完成，则执行异步读取操作。

代码第64-97行是客户端异步读取时间服务器服务端应答消息的处理逻辑，代码第49行我们调用AsynchronousSocketChannel的read方法异步读取服务端的响应消息，由于read操作是异步的，所以我们通过内部匿名类实现CompletionHandler<Integer, ByteBuffer>接口，当读取完成被JDK回调时，我们构造应答消息。第56-63行我们从CompletionHandler的ByteBuffer中读取应答消息，然后打印结果。

第197-96行，当读取发生异常时，我们关闭链路，同时调用CountDownLatch的countDown方法让AsyncTimeClientHandler线程执行完毕，客户端退出执行。

需要指出的是，正如之前的NIO例程，我们并没有完整的处理网络的半包读写，当对例程进行功能测试的时候没有问题，但是，如果对代码稍加改造，进行压力或者性能测试，就会发现输出结果存在问题。

由于半包的读写会作为专门的小节在Netty的应用和源码分析章节进行详细讲解，在NIO的入门章节我们就不详细展开介绍，以便读者能够将注意力集中在NIO的入门知识上来。

下面的小节我们运行AIO版本的时间服务器程序，并通过打印线程堆栈的方式看下JDK回调异步Channel CompletionHandler的调用情况。