简单找了下发现网上没有关于Netty3比较完整的源码解析的文章，于是我就去读官方文档，为了加强记忆，翻译成了中文，有适当的简化。原文档地址：Netty3文档Chapter 1 开始1、开始之前运行demo的前提有两个：最新版本的Netty3和JDK1.5以上2、写一个Discard Server最简单的协议就是Discard协议——忽略所有接收到的数据并且不作任何响应。我们从Netty处理I/O事件的handler实现开始：public class DiscardServerHandler extends SimpleChannelHandler { @Override public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) { } @Override public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) { e.getCause().printStackTrace(); Channel ch = e.getChannel(); ch.close(); }}DiscardServerHandler 继承SimpleChannelHandler——ChannelHandler的一个实现；messageReceived方法接收MessageEvent类型的参数，它包含接收的客户端数据；exceptionCaught方法在出现I/O错误或者处理事件时抛出错误时被调用，通常包含记录错误信息和关闭通道的动作；接下来写一个main方法来开启使用DiscardServerHandler的服务：public class DiscardServer { public static void main(String[] args) throws Exception { ChannelFactory factory = new NioServerSocketChannelFactory( Executors.newCachedThreadPool(), Executors.newCachedThreadPool()); ServerBootstrap bootstrap = new ServerBootstrap(factory); bootstrap.setPipelineFactory(new ChannelPipelineFactory() { public ChannelPipeline getPipeline() { return Channels.pipeline(new DiscardServerHandler()); } }); bootstrap.setOption(“child.tcpNoDelay”, true); bootstrap.setOption(“child.keepAlive”, true); bootstrap.bind(new InetSocketAddress(8080)); }}ChannelFactory是创建和管理Channel及其关联资源的工厂，它负责处理所有I/O请求并且执行I/O生成ChannelEvent。但是它不是自己创建I/O线程，而是从调用构造方法时指定的线程池中获取线程。服务端应用使用NioServerSocketChannelFactory；ServerBootstrap是一个设置服务端的帮助类；当服务端接收到一个新的连接，指定的ChannelPipelineFactory就会创建一个新的ChannelPipeline，这个新的Pipeline包含一个DiscardServerHandler对象；你可以给Channel实现设置具体的参数，选项带"child.“前缀代表应用在接收到的Channel上而不是服务端本身的ServerSocketChannel；剩下的就是绑定端口启动服务，可以绑定多个不同的端口。3、研究接收到的数据我们可以通过"telnet localhost 8080"命令去测试服务，但因为是Discard服务，我们都不知道服务是否正常工作。所以我们修改下服务，让它打印出接收到的数据。@Overridepublic void messageReceived(ChannelHandlerContext ctx, MessageEvent e) { ChannelBuffer buf = (ChannelBuffer) e.getMessage(); while(buf.readable()) { System.out.println((char) buf.readByte()); System.out.flush(); }}ChannelBuffer是Netty基本的存储字节的数据结构，跟NIO的ByteBuffer类似，但是更容易使用更灵活。比如Netty允许你在尽量少的内存复制次数的情况下把多个ChannelBuffer组合成一个。4、写一个Echo服务一个服务通常对请求是有响应的。接下来我们尝试写一个实现Echo协议——将接收的数据原路返回给客户端的服务：@Overridepublic void messageReceived(ChannelHandlerContext ctx, MessageEvent e) { Channel ch = e.getChannel(); ch.write(e.getMessage());}MessageEvent继承了ChannnelEvent，一个ChannnelEvent持有它相关的Channel的引用。我们可以获取这个Channel然后调用写方法写入数据返回给客户端。5、写一个时间服务这次我们实现一个时间协议——在不需要任何请求数据的情况下返回一个32位整型数字并且在发送之后关闭连接。因为我们忽略请求数据，只需要在连接建立的发送消息，所以这次不能使用messageReceived方法而是重写channelConnected方法：@Overridepublic void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) { Channel ch = e.getChannel(); ChannelBuffer time = ChannelBuffers.buffer(4); time.writeInt((int) (System.currentTimeMillis() / 1000L + 2208988800L)); ChannelFuture f = ch.write(time); f.addListener(new ChannelFutureListener() { public void operationComplete(ChannelFuture future) { Channel ch = future.getChannel(); ch.close(); } });}channelConnected方法在连接建立的时间被调用，然后我们写入一个32位整型数字代表以秒为单位的当前时间；我们使用ChannelBuffers工具类分配了一个容量为4字节的ChannelBuffer来存放这个32位整型数字；然后我们把ChannelBuffer写入Channel…等一下，flip方法哪里去了？在NIO中我们不是要在写入通道前调用ByteBuffer的flip方法的吗？ChannelBuffer没有这个方法，因为它有两个指针，一个用于读操作一个用于写操作。当数据写入ChannelBuffer时写索引增加而读索引不变。读索引和写索引相互独立。对比之下，Netty的ChannelBuffer比NIO的buffer更容易使用。另外需要注意的一点是ChannelBuffer的write方法返回的是一个ChannelFuture对象。它表示一个还未发生的I/O操作，因为Netty中所有操作都是异步的。所以我们必须在ChannelFuture收到操作完成的通知之后才能关闭Channel。哦，对了，close方法也是返回ChannelFuture…那么问题来了，我们如何得到操作完成的通知呢？只需要简单得向返回的ChannelFuture对象中添加一个ChannelFutureListener，这里我们创建了一个ChannelFutureListener的匿名内部类，它在操作完成的时候会关闭Channel。6、写一个时间客户端我们还需要一个遵守时间协议，即能把整型数字翻译成日期的客户端。Netty服务端和客户端唯一的区别就是要求不同的Bootstrap和ChannelFactory：public static void main(String[] args) throws Exception { String host = args[0]; int port = Integer.parseInt(args[1]); ChannelFactory factory = new NioClientSocketChannelFactory( Executors.newCachedThreadPool(), Executors.newCachedThreadPool()); ClientBootstrap bootstrap = new ClientBootstrap(factory); bootstrap.setPipelineFactory(new ChannelPipelineFactory() { public ChannelPipeline getPipeline() { return Channels.pipeline(new TimeClientHandler()); } }); bootstrap.setOption(“tcpNoDelay”, true); bootstrap.setOption(“keepAlive”, true); bootstrap.connect(new InetSocketAddress(host, port));}NioClientSocketChannelFactory，用来创建一个客户端Channel；ClientBootstrap是ServerBootStrap在客户端的对应部分；需要注意的是设置参数时不需要"child.“前缀，客户端SocketChannel没有父Channel；对应服务端的bind方法，这里我们需要调用connect方法。另外我们需要一个ChannelHandler实现，负责把接收到服务端返回的32位整型数字翻译成日期并打印出来，然后断开连接：public class TimeClientHandler extends SimpleChannelHandler { @Override public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) { ChannelBuffer buf = (ChannelBuffer) e.getMessage(); long currentTimeMillis = buf.readInt() * 1000L; System.out.println(new Date(currentTimeMillis)); e.getChannel().close(); } @Override public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) { e.getCause().printStackTrace(); e.getChannel().close(); }}看上去很简单是吧？但是实际运行过程中这个handler有时会抛出一个IndexOutOfBoundsException。下一节我们会讨论为什么会这样。7、处理基于流的传输7.1、一个关于Socket Buffer的小警告在像TCP/IP那样基于流的传输中，接收数据保存在一个socket接收缓存中。但是这个缓存不是一个以包为单位的队列，而是一个以字节为单位的队列。这就意味着，即使发送两个独立的消息，操作系统会把他们视为一个字节串。因此，不能保证你读到的和另一端写入的一样。所以，不管是客户端还是服务端，对于接收到的数据都需要整理成符合应用程序逻辑的结构。7.2、第一种解决方式回到前面的时间客户端的问题，32位整型数字很小，但是它也是可以拆分的，特别是当流量上升的时候，被拆分的可能性也随之上升。一个简单的处理方式就是内部创建一个累计的缓存，直到接收满4个字节才进行处理。private final ChannelBuffer buf = dynamicBuffer();@Overridepublic void messageReceived(ChannelHandlerContext ctx, MessageEvent e) { ChannelBuffer m = (ChannelBuffer) e.getMessage(); buf.writeBytes(m); if (buf.readableBytes() >= 4) { long currentTimeMillis = buf.readInt() * 1000L; System.out.println(new Date(currentTimeMillis)); e.getChannel().close(); }}ChannelBuffers.dynamicBuffer()返回一个自动扩容的ChannelBuffer；所有接收的数据都累积到这个动态缓存中；handler需要检查缓存是否满4个字节，是的话才能继续业务逻辑；否则，Netty会在数据继续到达之后持续调用messageReceive。7.3、第二种解决方案第一种方案有很多问题，比如一个复杂的协议，由多个可变长度的域组成，这种情况下第一种方案的handler就无法支持了。你会发现你可以添加多个ChannelHandler到ChannelPipeline中，利用这个特性，你可以把一个臃肿的ChannelHandler拆分到多个模块化的ChannelHandler中，这样可以降低应用程序的复杂度。比如，你可以把TimeClientHandler拆分成两个handler：TimeDecoder，负责分段问题；最初那个简版的TimeClientHandler.Netty提供了可扩展的类帮助你实现TimeDecoder：public class TimeDecoder extends FrameDecoder { @Override protected Object decode(ChannelHandlerContext ctx, Channel channel, ChannelBuffer buffer) { if (buffer.readableBytes() < 4) { return null; } return buffer.readBytes(4); }}FrameDecoder是ChannelHandler的一种实现，专门用来处理分段问题；FrameDecoder在每次接收到新的数据时调用decode方法，携带一个内部维持的累积缓存；如果返回null，说明目前数据接收的还不够，当数据量足够时FrameDecoder会再次调用方法；如果返回非null对象，代表解码成功，FrameDecoder会丢弃累积缓存中剩余的数据。你无需提供批量解码，FrameDecoder会继续调用decode方法直到返回null。拆分之后，我们需要修改TimeClient的ChannelPipelineFactory实现：bootstrap.setPipelineFactory(new ChannelPipelineFactory() { public ChannelPipeline getPipeline() { return Channels.pipeline( new TimeDecoder(), new TimeClientHandler()); }});Netty还提供了进一步简化解码的ReplayingDecoder：public class TimeDecoder extends ReplayingDecoder<VoidEnum> { @Override protected Object decode( ChannelHandlerContext ctx, Channel channel, ChannelBuffer buffer, VoidEnum state) { return buffer.readBytes(4); } }此外，Netty提供了一批开箱即用的解码器，让你可以简单得实现大多数协议：org.jboss.netty.example.factorial 用于二进制协议；org.jboss.netty.example.telnet 用于基于行的文本协议.8、用POJO替代ChannelBuffer上面的demo我们都是用ChannelBuffer作为协议化消息的基本数据结构，这一节我们用POJO替代ChannelBuffer。将从ChannelBuffer提取信息的代码跟handler分离开，会使handler变得更加可维护的和可重用的。从上面的demo里不容易看出这个优势，但是实际应用中分离很有必要。首先，我们定义一个类型UnixTime：public class UnixTime { private final int value; public UnixTime(int value) { this.value = value; } public int getValue() { return value; } @Override public String toString() { return new Date(value * 1000L).toString(); }}现在我们可以修改TimeDecoder让它返回一个UnixTime而不是ChannelBuffer：@Overrideprotected Object decode(ChannelHandlerContext ctx, Channel channel, ChannelBuffer buffer) { if (buffer.readableBytes() < 4) { return null; } return new UnixTime(buffer.readInt());}编码器改了，那么相应的TimeClientHandler就不会继续使用ChannelBuffer：@Overridepublic void messageReceived(ChannelHandlerContext ctx, MessageEvent e) { UnixTime m = (UnixTime) e.getMessage(); System.out.println(m); e.getChannel().close();}同样的技术也可以应用到服务端的TimeServerHandler上：@Overridepublic void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) { UnixTime time = new UnixTime((int)(System.currentTimeMillis() / 1000)); ChannelFuture f = e.getChannel().write(time); f.addListener(ChannelFutureListener.CLOSE);}能这样运用的前提是有一个编码器，可以把UnixTime对象翻译成ChannelBuffer：public class TimeEncoder extends SimpleChannelHandler { public void writeRequested(ChannelHandlerContext ctx, MessageEvent e) { UnixTime time = (UnixTime) e.getMessage(); ChannelBuffer buf = buffer(4); buf.writeInt(time.getValue()); Channels.write(ctx, e.getFuture(), buf); }}一个编码器重写writeRequested方法拦截一个写请求。这里需要注意的一点是，尽管这里的writeRequested方法参数里也有一个MessageEvent对象，客户端TimeClientHandler的messageReceived的参数里也有一个，但是它们的解读是完全不同的。一个ChannelEvent可以是upstream也可以是downstream事件，这取决于事件的流向。messageReceived方法里的MessageEvent是一个upstream事件，而writeRequested方法里的是downstream事件。当把POJO类转化为ChannelBuffer后，你需要把ChannelBuffer转发到之前在ChannelPipeline内的ChannelDownstreamHandler，也就是TimeServerHandler。Channels提供了多个帮助方法创建和发送ChanenlEvent。同样，TimeEncoder也需要加入到服务端的ChannelPipeline中：bootstrap.setPipelineFactory(new ChannelPipelineFactory() { public ChannelPipeline getPipeline() { return Channels.pipeline( new TimeServerHandler(), new TimeEncoder()); }});9、关闭你的应用程序为了关闭I/O线程让应用程序优雅得退出，我们需要释放ChannelFactory分配的资源。一个典型网络应用程序的关闭过程分为三步：关闭所有服务端socket连接；关闭所有非服务端socket连接（包括客户端socket和服务端接收到的socket）；释放ChannelFactory使用的所有资源。应用到TimeClient上：ChannelFuture future = bootstrap.connect(…);future.awaitUninterruptibly();if (!future.isSuccess()) { future.getCause().printStackTrace();}future.getChannel().getCloseFuture().awaitUninterruptibly();factory.releaseExternalResources();CilentBootStrap的connect方法返回一个ChannelFuture，当连接尝试成功或者失败时会通知到ChannelFuture。它还持有连接尝试关联的Channel的引用；ChannelFuture.awaitUninterruptibly()等待ChannelFuture确定连接是否尝试成功；如果连接失败，我们打印出失败的原因。ChannelFuture.getCause()会在连接即没有成功也没有取消的情况下返回失败的原因；连接尝试的情况处理之后，我们还需要等待连接关闭。每个Channel有它自己的closeFuture，用来通知你连接关闭然后你可以针对关闭做一些动作。即使连接尝试失败了，closeFuture仍然会被通知，因为Channel会在连接失败后自动关闭；所有连接关闭之后，剩下的就是释放ChannelFactory使用的资源了。释放过程很简单，调用它的releaseExternalResources方法，所有相关的NIO Selector和线程池将会自动关闭。关闭一个客户端很简单，那服务端呢？你需要从端口解绑并关闭所有接收到的连接。前提是你需要一个保持跟踪活跃连接的数据结构，Netty提供了ChannelGroup。ChannelGroup是Java集合API一个特殊的的扩展，它代表一组打开的Channel。如果一个Channel被添加到ChannelGroup，然后这个Channel被关闭了，它会从ChannelGroup中自动移除。你可以对同一ChannelGroup中的Channel做批量操作，比如在关闭服务的时候关闭所有Channel。要跟踪打开的socket，你需要修改TimeServerHandler，把新打开的Channel添加到全局的ChannelGroup变量中。ChannelGroup是线程安全的。@Overridepublic void channelOpen(ChannelHandlerContext ctx, ChannelStateEvent e) { TimeServer.allChannels.add(e.getChannel());}现在我们自动维持了一个包含所有活跃Channel的列表，关闭服务端就像关闭客户端一样容易了。public class TimeServer { static final ChannelGroup allChannels = new DefaultChannelGroup(“time-server”); public static void main(String[] args) throws Exception { … ChannelFactory factory = …; … ServerBootstrap bootstrap = …; … Channel channel = bootstrap.bind(new InetSocketAddress(8080)); allChannels.add(channel); waitForShutdownCommand(); ChannelGroupFuture future = allChannels.close(); future.awaitUninterruptibly(); factory.releaseExternalResources(); }}DefaultChannelGroup构造方法接收组名为参数，组名是它的唯一标识；ServerBootstrap的bind方法返回一个服务端的绑定指定本地地址的Channel，调用Channel的close方法将会使它与本地地址解绑；所有Channel类型都可以被添加到ChannelGroup中，不管是客户端、服务端或是服务端接收的。因为你可以在服务器关闭时同时关闭绑定的Channel和接收到的Channel；waitForShutdownCommand()是一个等待关闭信号的虚构方法。我们可以对ChannelGroup中的Channel进行统一操作，这里我们调用close方法，相当于解绑服务端Channel并且异步关闭所有接收到的Channel。close方法返回一个功能和ChannelFuture相近的ChannelGroupFuture，在所有连接都成功关闭通知我们。10、总结这一节我们快速浏览了Netty，示范了如何用Netty写一个能正常工作的网络应用。下一节将介绍Netty的更多细节。