认识netty的基本组件

Java NIO VS Netty

有了 Java NIO，而且 Netty 也是基于 Java NIO 实现，那么为什么不能直接用 Java NIO 来实现网络通讯模块呢？ 接下来我就给各人表明一下缘故原由。
如果我们用 Java NIO 来开发网络通讯组件，势必会直接面临很多网络通讯的题目。比如，网络连接异常怎样处理、网络的闪断怎么处理、网络拥堵、拆包粘包等一大堆网络通讯的题目。同时还会面临性能优化的题目，比如成熟的中间件为了提升通讯性能，以及提升处理哀求量，会计划成 reactor 模式。
所以，直接用 Java NIO 做通讯模块，会有很多的生产情况的题目等待我们去处理，大部分经验并不是很资深的同砚是很难实现的。
但对比下来，Netty 开发通讯组件则有很多上风。

• 起首，Netty 简化了 Java NIO 的 API，封装了底层很多复杂的网络通细节，让我们开发步伐变得很简单。
  
• 其次，Netty 还提供了很多的高级功能，易于二次扩展。
  
• 最重要的是，优秀的 Netty 计划实现了高性能、高并发、高吞吐、高可靠的网络通讯。
  
• 最后，大量的商业项目都使用了 Netty 作为网络通讯模块，比如，Dubbo、RocketMQ。颠末很多生产情况的验证后，Netty 可以说是 Java 软件里最成熟、最流行的网络通讯模块。
  

但是 Netty 也是有劣势的，Netty 为了更好地封装 Java NIO 创造了很多抽象的概念，这些抽象概念对于初学者来说难度并不小。
总体来说，Netty 相对于 Java NIO 确实更加完善和健壮，但是也难于理解。
为了让你更好地理解 Netty，下面我会带各人用 Netty 简单地实现一个有服务端和客户端的网络通讯 Demo。
Demo：Netty 入门步伐

在这个 Demo 步伐中，我会给各人详细表明步伐中每步的意义，让各人更快地入门 Nettty 开发。
这里我会从服务端和客户端这两头分别讲起。
服务端代码

服务端代码包括服务端启动类和处理网络事件的 Handler 类。启动类重要是一些 Netty 核心类的初始化及端口的绑定；Handler 类是用来处理网络事件对应的业务逻辑。
起首，服务端启动类 NettyServer 代码如下：
 java

1. public class NettyServer {
3.     public static void main(String[] args) {
4.         // 第一步，分别创建两个处理网络的EventLoopGroup。
5.         EventLoopGroup parentGroup = new NioEventLoopGroup();   //Acceptor线程组
6.         EventLoopGroup childGroup = new NioEventLoopGroup();    //Processor或Handler 线程组
8.         try{
9.             // 第二步，初始化服务器
10.             ServerBootstrap serverBootstrap = new ServerBootstrap(); //相当于Netty服务器
11.             // 第三步，给服务器做一系列的配置。
12.             serverBootstrap
13.                     .group(parentGroup, childGroup)
14.                     .channel(NioServerSocketChannel.class)//监听端口的ServerSocketChannel
15.                     .option(ChannelOption.SO_BACKLOG, 1024)
16.                     .childHandler(new ChannelInitializer<SocketChannel>() { //处理每个连接的 SocketChannel,SocketChannel代表每一个连接
17.                         @Override
18.                         protected void initChannel(SocketChannel socketChannel) throws Exception {
19.                             socketChannel.pipeline().addLast(new NettyServerHandler()); //针对网络请求的处理逻辑
20.                         }
21.                     });
22.             System.out.println("Server 启动了");
23.             // 第四步，绑定端口。
24.             ChannelFuture channelFuture =  serverBootstrap.bind(50099).sync(); //监听指定端口
25.             // 第五步，等待服务器关闭
26.             channelFuture.channel().closeFuture().sync();// 同步等待关闭启动服务器的结果
27.         }catch (Exception ex){
28.             ex.printStackTrace();
29.         }finally {
30.             parentGroup.shutdownGracefully();
31.             childGroup.shutdownGracefully();
32.         }
34.     }
35. }

复制代码

• 第一步，需要创建两个 EventLoopGroup。EventLoopGroup 是来处理网络事件的，本质是个线程组，第一个 parentGroup 各人可以理解成 Reactor 模式里的 Acceptor，也就是接收网络事件的线程；但是 Acceptor 并不处理网络事件，会把网络事件交给 Processor 线程，在这里就是 childGroup 线程组。EventLoopGroup 是比较复杂的，本文后面部分会给各人详细介绍。
  
• 第二步，初始化服务器类 ServerBootstrap，也就是说 ServerBootstrap 代表服务器。
  
• 第三步，给服务器类 ServerBootstrap 做一些须要的配置，包括前面定义的两个线程组作为初始化的参数，然后选取服务端处理连接的 NioServerSocketChannel。最后，也是最重要的，配置处理网络事件的类，这里我们定义了 NettyServerHandler 作为处理 SocketChannel 上的网络事件的类。这里，各人还可以看随处理 SocketChannel 的类可以用链式调用，也就是这里的 pipeline()，这是一个很好的计划。
  
• 第四步，服务端需要一个端口来对外提供服务，这里绑定的端口是 50099。
  
• 第五步，等待服务器关闭。
  

我们接下来看看自定义的处理网络事件的类 NettyServerHandler 是怎么写的。
NettyServerHandler 这个类继承了 Netty 类库里提供的类 ChannelInboundHandlerAdapter 来实现业务操作。也就是说，Netty 已经把复杂的网络题目封装好了，我们只要关注数据处理就好了。处理网络事件的类 NettyServerHandler 代码如下：
 java

1. // 这个类很像 reactor 模式里的processor线程，负责读区请求然后返回响应
2. public class NettyServerHandler extends ChannelInboundHandlerAdapter {
3.     @Override
4.     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
5.         // 第一步，获取客户端请求的内容
6.         ByteBuf buffer= (ByteBuf) msg;
7.         byte[] requestBytes = new byte[buffer.readableBytes()];
8.         buffer.readBytes(requestBytes);
9.         
10.         String request = new String(requestBytes,"UTF-8");
11.         System.out.println("收到请求"+request);
12.         //第二步，向客户端返回信息
13.         String response = "收到请求后返回响应";
14.         ByteBuf responseBuffer = Unpooled.copiedBuffer(response.getBytes());
15.         ctx.write(responseBuffer);
16.     }
18.     @Override
19.     //
20.     public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
21.         // 真正的发送
22.         ctx.flush();
23.     }
25.     @Override
26.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
27.         cause.printStackTrace();
28.         ctx.close();
29.     }
31.     @Override
32.     // 只要channel打通了，就会执行
33.     public void channelActive(ChannelHandlerContext ctx) throws Exception {
34.         System.out.println("Server is Active......");
35.     }
36. }

复制代码

• 第一步，当有客户端向这个服务端发送哀求时，服务端会发送网络读事件。这时会激发 channelRead() 的实验。起首初始化一个 byte 数组，然后从哀求中读出二进制数据，最后转化成中文字符。
  
• 第二步，调用方法 ctx.write()，把响应数据发到客户端。
  

但是需要阐明的是，调用 ctx.write() 时并不代表数据已经发送了，因为操作体系要根据本身的实际情况发送数据。这时如果我们对一致性要求很高，就可以重载 channelReadComplete() 方法，并调用 ctx.flush() 方法，这样数据就能同步发送出去了。
当然另有别的方法比如 channelActive()，这个方法表示有客户端连接并且连接成功后 Channel 也是可用的。
结合上面两个类，我给各人画张服务器端流程图：

好，服务端的步伐就介绍完了，接下来介绍客户端的步伐。
客户端代码

与服务端步伐一样，客户端步伐也分为启动类和处理网络事件的 Handler 类。
服务端启动类 NettyClient 代码如下：
 java

1. public class NettyClient {
2.     public static void main(String[] args) {
3.         // 第一步，定义一个EventLoopGroup
4.         EventLoopGroup parent = new NioEventLoopGroup();   //Acceptor线程组
5.         try{
6.             Bootstrap bootstrap= new Bootstrap();
7.             // 第二步，对客户端做各种配置
8.             bootstrap.group(parent)
9.                     .channel(NioSocketChannel.class)
10.                     .option(ChannelOption.TCP_NODELAY,true)
11.                     .handler(new ChannelInitializer<Channel>() {
12.                         @Override
13.                         protected void initChannel(Channel channel) throws Exception {
14.                             channel.pipeline().addLast(new NettyClintHandler());
15.                         }
16.                     });
17.             //第三步，向服务端连接
18.             ChannelFuture channelFuture= bootstrap.connect("127.0.0.1",50099).sync();
19.             channelFuture.channel().closeFuture().sync();
20.         }catch (Exception ex){
21.             ex.printStackTrace();
22.         }
23.     }
24. }

复制代码

• 第一步，定义一个 EventLoopGroup，与服务端启动类差别的是，客户端启动类只定义了一个 EventLoopGroup 对象，而定义的这个对象就是分配连接事件的 Acceptor 线程。为什么是这样的计划？因为客户端的连接并不像服务端那样有成千上万的连接，网络事件少。所以，不需要 Acceptor 线程与 Processor 线程分开来分配差别的任务。
  
• 第二步，定义一个启动类 Bootstrap，并对 Bootstrap 举行参数配置，比如说 Channel 用的是 NioSocketChannel （和服务器端用的不一样），同时也需要自定义一个 NettyClintHandler 来处理网络事件。
  
• 第三步，向服务端哀求连接。
  

接下来看看客户端处理网络事件的 Handler 类是怎样写的。
处理网络事件的类 NettyClientHandler 代码如下：
 java

1. public class NettyClintHandler extends ChannelInboundHandlerAdapter {
2.         // 第一步，定义要发送的内容
3.         private ByteBuf requestBuffer;
4.         
5.         public NettyClintHandler(){
6.             byte[] requestBytes = "发送请求".getBytes();
7.             requestBuffer = Unpooled.buffer(requestBytes.length);
8.             requestBuffer.writeBytes(requestBytes);
9.         }
11.     @Override
12.     public void channelActive(ChannelHandlerContext ctx) throws Exception {
13.             // 第二步，向服务端发送消息
14.             ctx.writeAndFlush(requestBuffer);
15.     }
17.     @Override
18.     public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
19.             // 第三步，读取服务端的响应
20.         ByteBuf responseBuffer = (ByteBuf) msg;
21.         byte[] responseBytes = new byte[responseBuffer.readableBytes()];
22.         responseBuffer.readBytes(responseBytes);
24.         String response = new String(responseBytes,"UTF-8");
25.         System.out.println("收到服务端的响应："+response);
26.     }
28.     @Override
29.     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
30.         cause.printStackTrace();
31.         ctx.close();
32.     }
33. }

复制代码

• 第一步，定义客户端要向服务端发送的哀求信息。
  
• 第二步，当客户端对服务端的连接哀求成功后，同时 channel 连接正常时，就会激发方法 channelActive() 的实验，在这个方法中我们通过调用 ctx.writeAndFlush(requestBuffer) 来发送哀求。
  
• 第三步，发送哀求后，服务端会向客户端发送响应，这时会激发 channelRead() 方法的实验，我们可以读取响应。
  

到这里，用 Netty 实现服务端和客户端的代码就解说完了，各人可以看到 Netty 把底层的 Java NIO 全部屏蔽掉了，我们只要关注配置参数，只关心业务实现类就可以了。
建议各人可以在本地尝试运行一下，这样理解地会更加深刻。
从代码中学习到的计划头脑

• 网络功能和业务逻辑功能分离
  

起首，各人可以看到，负责通讯模块的启动类和负责处理网络事件的 Handler 类是分开的，这样的好处是 Handler 类的业务逻辑功能和启动类的通讯功能分离。功能分类的好处是显而易见的，这样做可以淘汰耦合。

• 责任链计划模式
  

根据上述代码，对于网络事件的处理可以用多个 Handler 类对象处理。Netty 采用了链式调用来让各个 Handler 类对象串联起来。其实，这种计划也是为了淘汰耦合，我们可以对网络事件的处理分成几个步调，每一个步调由一个 Handler 负责。这样一方面做到了解耦，代表差别功能的 Handler 类互不影响。另一方面，我们对于某个 Channel 可以灵活地增长或淘汰处理它的 Hanlder。这样就会更加灵活便捷。

• 事件驱动
  

另外，事件驱动的头脑也有很好的表现，在 Handler 类里有许多表示事件的方法，比如表示读事件的方法 channelRead()，表示 Channel 连接活泼的方法 channelActive()。事件驱动的好处是，代码会有很好的可读性，同时比较轻易理解。
总结

• 起首，阐明确 Netty 的使用场景。
  
• 然后，讲述了 Java NIO 开发通讯模块的一些题目，以及 Netty 开发通讯模块的上风。
  
• 之后，重点解说了用 Netty 实现服务端和客户端的代码，让你对 Netty 的使用有个初步的领会，同时也对 Netty 相关的一些组件举行了解说。
  
• 最后，我们从代码例子中学到了一些很优秀的计划头脑，比如，解耦、事件驱动。
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。