Netty之Netty入门应用（三）

矫情吗；* 2023-03-01 10:41 18阅读 0赞

### 文章目录 ###

*   *  Netty
     *  分析
     *   *  总结

## Netty ##

package main.com.phei.netty.basic;
    
    import io.netty.bootstrap.ServerBootstrap;
    import io.netty.channel.ChannelFuture;
    import io.netty.channel.ChannelInitializer;
    import io.netty.channel.ChannelOption;
    import io.netty.channel.EventLoopGroup;
    import io.netty.channel.nio.NioEventLoopGroup;
    import io.netty.channel.socket.SocketChannel;
    import io.netty.channel.socket.nio.NioServerSocketChannel;
    
    /** * @author lilinfeng * @version 1.0 * @date 2014年2月14日 */
    public class TimeServer { 
    
        /** * @param args * @throws Exception */
        public static void main(String[] args) throws Exception { 
            int port = 8080;
            if (args != null && args.length > 0) { 
                try { 
                    port = Integer.valueOf(args[0]);
                } catch (NumberFormatException e) { 
                    // 采用默认值
                }
            }
            new TimeServer().bind(port);
        }
    
        public void bind(int port) throws Exception { 
            // 配置服务端的NIO线程组
            EventLoopGroup bossGroup = new NioEventLoopGroup();
            EventLoopGroup workerGroup = new NioEventLoopGroup();
            try { 
                long start = System.currentTimeMillis();
                ServerBootstrap b = new ServerBootstrap();
                b.group(bossGroup, workerGroup)
                        .channel(NioServerSocketChannel.class)
                        .option(ChannelOption.SO_BACKLOG, 1024)
                        .childHandler(new ChildChannelHandler());
                // 绑定端口，同步等待成功
                ChannelFuture f = b.bind(port).sync();
    
                long end = System.currentTimeMillis();
                System.out.println("服务器启动成功:" + (end - start) + " ms");
                // 等待服务端监听端口关闭
                f.channel().closeFuture().sync();
            } finally { 
                // 优雅退出，释放线程池资源
                bossGroup.shutdownGracefully();
                workerGroup.shutdownGracefully();
            }
        }
    
        private class ChildChannelHandler extends ChannelInitializer<SocketChannel> { 
            @Override
            protected void initChannel(SocketChannel arg0) throws Exception { 
                arg0.pipeline().addLast(new TimeServerHandler());
            }
    
        }
    }

package main.com.phei.netty.basic;
    
    import io.netty.bootstrap.Bootstrap;
    import io.netty.channel.ChannelFuture;
    import io.netty.channel.ChannelInitializer;
    import io.netty.channel.ChannelOption;
    import io.netty.channel.EventLoopGroup;
    import io.netty.channel.nio.NioEventLoopGroup;
    import io.netty.channel.socket.SocketChannel;
    import io.netty.channel.socket.nio.NioSocketChannel;
    
    /** * @author lilinfeng * @version 1.0 * @date 2014年2月14日 */
    public class TimeClient { 
    
        /** * @param args * @throws Exception */
        public static void main(String[] args) throws Exception { 
            int port = 8080;
            if (args != null && args.length > 0) { 
                try { 
                    port = Integer.valueOf(args[0]);
                } catch (NumberFormatException e) { 
                    // 采用默认值
                }
            }
            new TimeClient().connect(port, "127.0.0.1");
        }
    
        public void connect(int port, String host) throws Exception { 
            // 配置客户端NIO线程组
            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 { 
                                ch.pipeline().addLast(new TimeClientHandler());
                            }
                        });
    
                // 发起异步连接操作
                ChannelFuture f = b.connect(host, port).sync();
    
                // 当代客户端链路关闭
                f.channel().closeFuture().sync();
            } finally { 
                // 优雅退出，释放NIO线程组
                group.shutdownGracefully();
            }
        }
    }

package main.com.phei.netty.basic;
    
    import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    import io.netty.channel.ChannelHandlerAdapter;
    import io.netty.channel.ChannelHandlerContext;
    
    /** * @author lilinfeng * @version 1.0 * @date 2014年2月14日 */
    public class TimeServerHandler extends ChannelHandlerAdapter { 
    
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg)
                throws Exception { 
            ByteBuf buf = (ByteBuf) msg;
            byte[] req = new byte[buf.readableBytes()];
            buf.readBytes(req);
            String body = new String(req, "UTF-8");
            System.out.println("The time server receive order : " + body);
            String currentTime = "QUERY TIME ORDER".equalsIgnoreCase(body) ? new java.util.Date(
                    System.currentTimeMillis()).toString() : "BAD ORDER";
            ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());
            ctx.write(resp);
        }
    
        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { 
            ctx.flush();
        }
    
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { 
            ctx.close();
        }
    }

package main.com.phei.netty.basic;
    
    import io.netty.buffer.ByteBuf;
    import io.netty.buffer.Unpooled;
    import io.netty.channel.ChannelHandlerAdapter;
    import io.netty.channel.ChannelHandlerContext;
    
    import java.util.logging.Logger;
    
    /** 1. @author lilinfeng 2. @version 1.0 3. @date 2014年2月14日 */
    public class TimeClientHandler extends ChannelHandlerAdapter { 
    
        private static final Logger logger = Logger
                .getLogger(TimeClientHandler.class.getName());
    
        private final ByteBuf firstMessage;
    
        /** * Creates a client-side handler. */
        public TimeClientHandler() { 
            byte[] req = "QUERY TIME ORDER".getBytes();
            firstMessage = Unpooled.buffer(req.length);
            firstMessage.writeBytes(req);
    
        }
    
        @Override
        public void channelActive(ChannelHandlerContext ctx) { 
            ctx.writeAndFlush(firstMessage);
        }
    
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg)
                throws Exception { 
            ByteBuf buf = (ByteBuf) msg;
            byte[] req = new byte[buf.readableBytes()];
            buf.readBytes(req);
            String body = new String(req, "UTF-8");
            System.out.println("Now is : " + body);
        }
    
        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { 
            // 释放资源
            logger.warning("Unexpected exception from downstream : "
                    + cause.getMessage());
            ctx.close();
        }
    }

运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp_size_16_color_FFFFFF_t_70 1]

## 分析 ##

如下图所示，  
Reactor线程：其实就是一个死循环来遍历是否有事件注册到多路复用器selector上。  
白色框子里面的是NIO说对应的概念与流程，回顾一下NIO的流程：

1.  创建ServerSocketChannel与Selector
2.  将ServerSocketChannel注册到Selector上，监听ACCEPT
3.  启动，这个时候Selector中就已经在循环读取注册到其中的selectedKeys，来找到就绪的Channel
4.  找到就绪的Channel，配置参数，连接客户端与服务端，将SocketChannel注册到Selector上监听OP\_READ
5.  Selector轮询到OP\_READ，构造出ByteBuf对象读取数据

而白色框外面的对象则对应这Netty中的组件：  
Selector就对应这一个NioEventLoop线程组（bossGroup），  
workerGroup就是用来处理数据的工作线程组  
Netty中Handler使用的是ChannelHandler，而ChannelHandler更是使用`pipeline`（后面讲）

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp_size_16_color_FFFFFF_t_70 2]  
**启动流程**  
所以知道了对应关系，就有点明了了，  
服务端断码bind方法，创建一个ServerBootstrap，然后把必要的东西传进去，两个线程组，bossGroup和workerGroup，然后传入通道类型NioServerSocketChannel为TCP参数，然后将backlog设置为1024，最后绑定一个I/O事件处理类ChildChannelHandler  
配置完成之后，调用它的bind方法绑定监听端口，随后，调用它的同步阻塞方法syne等待绑定操作完成。完成之后Nety会返回一个 Channelfuture，它的功能类似于JDK的java. util. concurrent. Future，主要用于异步操作的通知回调。  
TimeServerHandler类主要是进行读写操作的，  
客户端代码connect方法，同样是创建一个Bootstrap，然后传入一个线程组，配置通道问NioSocketChannel，然后绑定一个Handler，同样的Handler使用pipline添加。  
到此就实现了Netty的简单代码编写。而我们的业务逻辑就只要在Handler里面写就可以了。

### 总结 ###

本章节讲解了Nety的入门应用，通过使用Nety重构时间服务器程序，可以发现相比于传统的NIO程序，Nety的代码更加简洁、开发难度低，扩展性也更好，非常适合作为基础通信框架被用户集成和使用在介绍Nety服务端和客户端时，简单地对代码进行了讲解。

> [Netty之Java I/O演进之路（一）][Netty_Java I_O]  
> [Netty之NIO入门（二）][Netty_NIO]  
> [Netty之Netty入门应用（三）][Netty_Netty]  
> [Netty之TCP粘包/拆包问题（四）][Netty_TCP]  
> [Netty之编解码开发（五）][Netty]  
> [Netty之ChannelPipeline(六)][Netty_ChannelPipeline]  
> [Netty之EventLoop和EventLoopGroup(七)][Netty_EventLoop_EventLoopGroup]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp_size_16_color_FFFFFF_t_70]: /images/20230208/681f8f22dcb64faeb8c57be9aaa8628f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200724104015168.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/2020072411114593.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5qdW5fZmVp,size_16,color_FFFFFF,t_70
[Netty_Java I_O]: https://blog.csdn.net/jianjun_fei/article/details/107505729
[Netty_NIO]: https://blog.csdn.net/jianjun_fei/article/details/107513219
[Netty_Netty]: https://blog.csdn.net/jianjun_fei/article/details/107555647
[Netty_TCP]: https://blog.csdn.net/jianjun_fei/article/details/107563110
[Netty]: https://blog.csdn.net/jianjun_fei/article/details/107772642
[Netty_ChannelPipeline]: https://blog.csdn.net/jianjun_fei/article/details/107787864
[Netty_EventLoop_EventLoopGroup]: https://blog.csdn.net/jianjun_fei/article/details/107956949