1.Netty源码分析一

Echo例子

Echo Client

public final class EchoClient {  
  
    static final String HOST = System.getProperty("host", "127.0.0.1");  
    static final int PORT = Integer.parseInt(System.getProperty("port", "8007"));  
    static final int SIZE = Integer.parseInt(System.getProperty("size", "256"));  
  
    public static void main(String[] args) throws Exception {  
        // Configure SSL.git  
        final SslContext sslCtx = ServerUtil.buildSslContext();  
  
        // Configure the client.  
        EventLoopGroup group = new NioEventLoopGroup();  
        try {  
            Bootstrap b = new Bootstrap();  
            b.group(group)  
             .channel(NioSocketChannel.class)  
             .option(ChannelOption.TCP_NODELAY, true)  
             .handler(new ChannelInitializer<SocketChannel>() {  
                 @Override  
                 public void initChannel(SocketChannel ch) throws Exception {  
                     ChannelPipeline p = ch.pipeline();  
                     if (sslCtx != null) {  
                         p.addLast(sslCtx.newHandler(ch.alloc(), HOST, PORT));  
                     }  
                     //p.addLast(new LoggingHandler(LogLevel.INFO));  
                     p.addLast(new EchoClientHandler());  
                 }  
             });  
  
            // Start the client.  
            ChannelFuture f = b.connect(HOST, PORT).sync();  
  
            // Wait until the connection is closed.  
            f.channel().closeFuture().sync();  
        } finally {  
            // Shut down the event loop to terminate all threads.  
            group.shutdownGracefully();  
        }  
    }  
}

EchoServer

public final class EchoServer {  
  
    static final int PORT = Integer.parseInt(System.getProperty("port", "8007"));  
  
    public static void main(String[] args) throws Exception {  
        // Configure SSL.  
        final SslContext sslCtx = ServerUtil.buildSslContext();  
  
        // Configure the server.  
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);  
        EventLoopGroup workerGroup = new NioEventLoopGroup();  
        final EchoServerHandler serverHandler = new EchoServerHandler();  
        try {  
            ServerBootstrap b = new ServerBootstrap();  
            b.group(bossGroup, workerGroup)  
             .channel(NioServerSocketChannel.class)  
             .option(ChannelOption.SO_BACKLOG, 100)  
             .handler(new LoggingHandler(LogLevel.INFO))  
             .childHandler(new ChannelInitializer<SocketChannel>() {  
                 @Override  
                 public void initChannel(SocketChannel ch) throws Exception {  
                     ChannelPipeline p = ch.pipeline();  
                     if (sslCtx != null) {  
                         p.addLast(sslCtx.newHandler(ch.alloc()));  
                     }  
                     //p.addLast(new LoggingHandler(LogLevel.INFO));  
                     p.addLast(serverHandler);  
                 }  
             });  
  
            // Start the server.  
            ChannelFuture f = b.bind(PORT).sync();  
  
            // Wait until the server socket is closed.  
            f.channel().closeFuture().sync();  
        } finally {  
            // Shut down all event loops to terminate all threads.  
            bossGroup.shutdownGracefully();  
            workerGroup.shutdownGracefully();  
        }  
    }  
}

在实际应用中，上述代码基本就是开发模板，唯一需要开发者做的就是自定义实现各种Handler，例如上述代码中的EchoClientHandler和EchoServerHandler。

public class EchoClientHandler extends ChannelInboundHandlerAdapter {  
  
    private final ByteBuf firstMessage;  
  
    /**  
     * Creates a client-side handler.     */    public EchoClientHandler() {  
        firstMessage = Unpooled.buffer(EchoClient.SIZE);  
        for (int i = 0; i < firstMessage.capacity(); i ++) {  
            firstMessage.writeByte((byte) i);  
        }  
    }  
  
    @Override  
    public void channelActive(ChannelHandlerContext ctx) {  
        ctx.writeAndFlush(firstMessage);  
    }  
  
    @Override  
    public void channelRead(ChannelHandlerContext ctx, Object msg) {  
        ctx.write(msg);  
    }  
  
    @Override  
    public void channelReadComplete(ChannelHandlerContext ctx) {  
       ctx.flush();  
    }  
  
    @Override  
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {  
        // Close the connection when an exception is raised.  
        cause.printStackTrace();  
        ctx.close();  
    }  
}

针对上述代码部分组件介绍：

• Bootstrap：Bootstrap用来创建客户端实例，ServerBootstrap用来创建服务端实例
• EventLoopGroup：eventLoop涉及Netty线程模型，服务端有两个，客户端有一个，它们就相当于Netty中的线程池。
• Channel：Netty 中的 Channel，没有直接使用 Java 原生的 ServerSocketChannel 和 SocketChannel，而是包装了 NioServerSocketChannel 和 NioSocketChannel 与之对应。
• handler：服务端handler用来处理接收到的新请求，客户端handler是处理请求过程中会使用到的handler。
• childHandler：- 这边的 handlers 是给新创建的连接用的，我们知道服务端 ServerSocketChannel 在 accept 一个连接以后，需要创建 SocketChannel 的实例，childHandler(…) 中设置的 handler 就是用于处理新创建的 SocketChannel 的，而不是用来处理 ServerSocketChannel 实例的。
• pipeline：handler 可以指定多个（需要上面的 ChannelInitializer 类辅助），它们会组成了一个 pipeline，它们其实就类似拦截器的概念，现在只要记住一点，每个 NioSocketChannel 或 NioServerSocketChannel 实例内部都会有一个 pipeline 实例。pipeline 中还涉及到 handler 的执行顺序。
• ChannelFuture：这个涉及到 Netty 中的异步编程，和 JDK 中的 Future 接口类似。