Netty 入门示例

Netty 入门示例

 

 

服务端代码示例

TimeServer

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

import  io.netty.bootstrap.ServerBootstrap; import  io.netty.channel.*; import  io.netty.channel.nio.NioEventLoopGroup; import  io.netty.channel.socket.nio.NioServerSocketChannel;     public  class  TimeServer {        public  void  bind( int  port)  throws  Exception {          //配置服务端的NIO线程组          //NioEventLoopGroup是个线程组，它包含了一组NIO线程，专门用于网络事件的处理，          //实际上它们就是Reactor线程组。          //这里创建两个的原因是一个用于服务端接受客户端的连接，另一个用于进行SocketChannel的网络读写。          EventLoopGroup bossGroup =  new  NioEventLoopGroup();          EventLoopGroup workerGroup =  new  NioEventLoopGroup();          try  {              //创建ServerBootstrap对象，它是Netty用于启动NIO服务端的辅助启动类，目的是降低服务端的开发复杂度。              ServerBootstrap b =  new  ServerBootstrap();              //调用ServerBootstrap的group方法，将两个NIO线程组当作入参传递到ServerBootstrap中。              //接着设置创建的Channel为NioServerSocketChannel，它的功能对应于JDK NIO类库中的ServerSocketChannel类。              //然后配置NioServerSocketChannel的TCP参数，此处将它的backlog设置为1024，              //最后绑定I/O事件的处理类ChildChannelHandler，它的作用类似于Reactor模式中的handler类，              //主要用于处理网络I/O事件，例如记录日志、对消息进行编解码等。              b.group(bossGroup, workerGroup)                      .channel(NioServerSocketChannel. class )                      .option(ChannelOption.SO_BACKLOG,  1024 )                      .childHandler( new  ChildChannelHandler());              //绑定端口，同步等待成功              //服务端启动辅助类配置完成之后，调用它的bind方法绑定监听端口              //随后，调用它的同步阻塞方法sync等待绑定操作完成。              //完成之后Netty会返回一个ChannelFuture，它的功能类似于JDK的java.util.concurrent.Future，主要用于异步操作的通知回调。              ChannelFuture f = b.bind(port).sync();                //等待服务端监听端口关闭              //使用f.channel().closeFuture().sync()方法进行阻塞,等待服务端链路关闭之后main函数才退出。              f.channel().closeFuture().sync();          }  finally  {              //优雅退出，释放线程池资源              //调用NIO线程组的shutdownGracefully进行优雅退出，它会释放跟shutdownGracefully相关联的资源。              bossGroup.shutdownGracefully();              workerGroup.shutdownGracefully();          }      }        private  class  ChildChannelHandler  extends  ChannelInitializer {          @Override          protected  void  initChannel(Channel channel)  throws  Exception {              channel.pipeline().addLast( new  TimeServerHandler());          }      }        public  static  void  main(String[] args)  throws  Exception {          new  TimeServer().bind( 8080 );      } }

1	<br>TimeServerHandler

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

import  io.netty.buffer.ByteBuf; import  io.netty.buffer.Unpooled; import  io.netty.channel.ChannelHandlerAdapter; import  io.netty.channel.ChannelHandlerContext;   //TimeServerHandler继承自ChannelHandlerAdapter，它用于对网络事件进行读写操作 //通常我们只需要关注channelRead和exceptionCaught方法。 public  class  TimeServerHandler  extends  ChannelHandlerAdapter {        @Override      public  void  channelRead(ChannelHandlerContext ctx, Object msg)  throws  Exception {          //做类型转换，将msg转换成Netty的ByteBuf对象。          //ByteBuf类似于JDK中的java.nio.ByteBuffer 对象，不过它提供了更加强大和灵活的功能。          ByteBuf buf = (ByteBuf) msg;          //通过ByteBuf的readableBytes方法可以获取缓冲区可读的字节数，          //根据可读的字节数创建byte数组          byte [] req =  new  byte [buf.readableBytes()];          //通过ByteBuf的readBytes方法将缓冲区中的字节数组复制到新建的byte数组中          buf.readBytes(req);          //通过new String构造函数获取请求消息。          String body =  new  String(req,  "UTF-8" );          System.out.println( "The time server receive order : "  + body);          //如果是"QUERY TIME ORDER"则创建应答消息，          String currentTime =  "QUERY TIME ORDER" .equalsIgnoreCase(body) ?  new  java.util.Date(                  System.currentTimeMillis()).toString() :  "BAD ORDER" ;          ByteBuf resp = Unpooled.copiedBuffer(currentTime.getBytes());          //通过ChannelHandlerContext的write方法异步发送应答消息给客户端。          ctx.write(resp);      }        @Override      public  void  channelReadComplete(ChannelHandlerContext ctx)  throws  Exception {          //调用了ChannelHandlerContext的flush方法，它的作用是将消息发送队列中的消息写入到SocketChannel中发送给对方。          //从性能角度考虑，为了防止频繁地唤醒Selector进行消息发送，          //Netty的write方法并不直接将消息写入SocketChannel中，调用write方法只是把待发送的消息放到发送缓冲数组中，          //再通过调用flush方法，将发送缓冲区中的消息全部写到SocketChannel中。          ctx.flush();      }        @Override      public  void  exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {          //当发生异常时，关闭ChannelHandlerContext，释放和ChannelHandlerContext相关联的句柄等资源。          ctx.close();      } }

　　

 

客户端代码示例：

TimeClient

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46

import  io.netty.bootstrap.Bootstrap; import  io.netty.channel.*; import  io.netty.channel.nio.NioEventLoopGroup; import  io.netty.channel.socket.nio.NioSocketChannel;   public  class  TimeClient {        public  void  connect( int  port, String host)  throws  Exception {          // 配置客户端NIO线程组          //首先创建客户端处理I/O读写的NioEventLoop Group线程组          EventLoopGroup group =  new  NioEventLoopGroup();          try  {              //继续创建客户端辅助启动类Bootstrap，随后需要对其进行配置。              //与服务端不同的是，它的Channel需要设置为NioSocketChannel              //然后为其添加handler，此处为了简单直接创建匿名内部类，实现initChannel方法，              //其作用是当创建NioSocketChannel成功之后，              //在初始化它的时候将它的ChannelHandler设置到ChannelPipeline中，用于处理网络I/O事件。              Bootstrap b =  new  Bootstrap();              b.group(group).channel(NioSocketChannel. class )                      .option(ChannelOption.TCP_NODELAY,  true )                      .handler( new  ChannelInitializer() {                          @Override                          protected  void  initChannel(Channel channel)  throws  Exception {                              channel.pipeline().addLast( new  TimeClientHandler());                          }                      });                // 发起异步连接操作              //客户端启动辅助类设置完成之后，调用connect方法发起异步连接，              //然后调用同步方法等待连接成功。              ChannelFuture f = b.connect(host, port).sync();                // 等待客户端链路关闭              //当客户端连接关闭之后，客户端主函数退出.              f.channel().closeFuture().sync();          }  finally  {              // 优雅退出，释放NIO线程组              //在退出之前，释放NIO线程组的资源。              group.shutdownGracefully();          }      }        public  static  void  main(String[] args)  throws  Exception {          new  TimeClient().connect( 8080 ,  "127.0.0.1" );      } }

 

TimeClientHandler

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

import  io.netty.buffer.ByteBuf; import  io.netty.buffer.Unpooled; import  io.netty.channel.ChannelHandlerAdapter; import  io.netty.channel.ChannelHandlerContext;   //重点关注三个方法：channelActive、channelRead和exceptionCaught。 public  class  TimeClientHandler  extends  ChannelHandlerAdapter {        private  final  ByteBuf firstMessage;        public  TimeClientHandler() {          byte [] req =  "QUERY TIME ORDER" .getBytes();          firstMessage = Unpooled.buffer(req.length);          firstMessage.writeBytes(req);      }        //当客户端和服务端TCP链路建立成功之后，Netty的NIO线程会调用channelActive方法      @Override      public  void  channelActive(ChannelHandlerContext ctx) {          //发送查询时间的指令给服务端          //调用ChannelHandlerContext的writeAndFlush方法将请求消息发送给服务端。          ctx.writeAndFlush(firstMessage);      }        //当服务端返回应答消息时，channelRead方法被调用      @Override      public  void  channelRead(ChannelHandlerContext ctx, Object msg) throws  Exception {          //从Netty的ByteBuf中读取并打印应答消息。          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) {          // 释放资源          //当发生异常时，打印异常日志，释放客户端资源。          ctx.close();      } }

　　

maven依赖：

1 2 3 4 5

<dependency>             <groupId>io.netty</groupId>             <artifactId>netty-all</artifactId>             <version> 5.0 . 0 .Alpha1</version>         </dependency>

　　

 运行结果

Connected to the target VM, address: '127.0.0.1:53243', transport: 'socket'
main,服务器开始监听端口，等待客户端连接.........
nioEventLoopGroup-3-2,The server receive  order : 我是客户端 nioEventLoopGroup-2-1
nioEventLoopGroup-3-3,The server receive  order : 我是客户端 nioEventLoopGroup-3-1
nioEventLoopGroup-3-1,The server receive  order : 我是客户端 nioEventLoopGroup-4-1

　　

Connected to the target VM, address: '127.0.0.1:53313', transport: 'socket'
Thread-1,客户端发起异步连接..........
Thread-0,客户端发起异步连接..........
Thread-2,客户端发起异步连接..........
nioEventLoopGroup-3-1,Server return Message：I am Server，消息接收 success!
nioEventLoopGroup-2-1,Server return Message：I am Server，消息接收 success!
nioEventLoopGroup-4-1,Server return Message：I am Server，消息接收 success!
Disconnected from the target VM, address: '127.0.0.1:53313', transport: 'socket'

Process finished with exit code 0

　　

 

posted on 2019-07-22 21:39  shoshana~ 阅读( ...) 评论( ...) 编辑 收藏

转载于:https://www.cnblogs.com/shoshana-kong/p/11228616.html