Netty编写Echo客户端——（二）

Echo客户端将会：

1. 连接到服务器
2. 发送一个或者多个消息
3. 对于每个消息，等待并接收从服务器发回的相同的消息
4. 关闭连接

通过ChannelHandler实现客户端逻辑

如同服务器，客户端将拥有一个用来处理数据的ChannelInboundHandler。在这个场景下，将拓展SimpleChannelInboundHandler类以处理所有必须的任务

• channnelActive()——在到服务器的连接已经建立之后将被调用
• channelRead()——当从服务器接收到一条消息时被调用
• exceptionCaught——在处理过程中引导异常时被调用

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.CharsetUtil;
import io.netty.channel.ChannelHandler.Sharable;

@Sharable				//标记该类的实例可以被多个Channel共享
public class EchoClientHandler extends SimpleChannelInboundHandler{

	@Override
	public void channelActive(ChannelHandlerContext ctx) throws Exception {
		ctx.writeAndFlush(Unpooled.copiedBuffer("Netty rocks!", CharsetUtil.UTF_8));	//当被通知Channel是活跃的时候，发送一条消息
	}
	
	@Override
	protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
		System.out.println("Client received: " + msg.toString(CharsetUtil.UTF_8));		//记录已接收消息转储
	}
	
	//在发生异常时。记录错误并关闭Channel
	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
		cause.printStackTrace();
		ctx.close();
	}

}

重写channelActive()方法，其将在一个连接建立时被调用。这确保了数据将会被尽可能快地写入服务器，其在这个场景下是一个编码了字符串“Netty rocks”的字节缓冲区

重写channelRead0()方法。每当接收数据时，都会调用这个方法。需要注意的是，由服务器发送的消息可能会被分块接收。也就是说，如果服务器发送了5个字节，那么不能保证这5个字节会被一次性接收。即使是对于这么少量的数据，channelRead0()方法也可能拥有2个字节的ByteBuf。作为一个面向流的协议，TCP保证了字节数据会按照服务器发送它们的顺序被接收

引导客户端

引导客户端类似于引导服务器，不同的是，客户端是使用主机和端口参数来连接远程地址，也就是这个得Echo服务器地址，而不是绑定到一个一直被监听的端口。

import java.net.InetSocketAddress;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

public class EchoClient {

	private final String host;
	private final int port;
	
	public EchoClient(String host, int port) {
		this.host = host;
		this.port = port;
	}
	
	public void start() throws Exception {
		EventLoopGroup group = new NioEventLoopGroup();
		try {
			Bootstrap b = new Bootstrap();				//创建bootstrap
			b.group(group)								//指定EventLoopGroup以处理客户端事件，需要适用于NIO的实现
			.channel(NioSocketChannel.class)			//适用于NIO传输的Channel类型
			.remoteAddress(new InetSocketAddress(host, port))			//设置服务器的InetSocketAddress
			.handler(new ChannelInitializer() {			//在创建Channel时，向ChannelPipeline中添加一个EchoClientHandler实例

				@Override
				protected void initChannel(SocketChannel ch) throws Exception {
					ch.pipeline().addLast(new EchoClientHandler());
				}
			});
			ChannelFuture f = b.connect().sync();		//连接到远程节点，阻塞等待直到连接完成
			f.channel().closeFuture().sync();			//阻塞直到Channel关闭
		} finally {	
			group.shutdownGracefully().sync();			//关闭线程池，并且释放所有的资源
		}
	}
	
	public static void main(String[] args) throws Exception {
		if(args.length != 2) {
			System.out.println("Usage:" + EchoClient.class.getSimpleName() + "");
			return;
		}
		String host = args[0];
		int port = Integer.parseInt(args[1]);
		new EchoClient(host, port).start();
	}
}

和之前一样，使用了NIO传输。注意，你可以在客户端和服务器上分别使用不同的传输。例如服务器使用NIO传输，而在客户端使用OIO传输。

下面是构建一个客户端的流程：

• 为初始化客户端，创建了一个Bootstrap实例；
• 为进行事件处理分配了一个NioEventLoopGroup实例，其中事件处理包括创建新的连接以及处理入站和出站数据
• 为服务器连接创建了一个InetSocketAddress实例；
• 当连接被建立时，一个EchoClientHandler实例会被安装到（该Channel的）ChannelPipeline中
• 在一切都设置完成后，调用了Bootstrap.connect()方法连接到远程节点；