Netty入门-示例

public static void main(String[] args) throws InterruptedException {
  //创建EventLoop
  NioEventLoopGroup master = new NioEventLoopGroup();
  //创建服务端引导
  ServerBootstrap bootstrap = new ServerBootstrap();
  bootstrap.group(master);
  bootstrap.option(ChannelOption.SO_KEEPALIVE, true);
  //指定使用NioServerSocketChannel作为Channel类型
  bootstrap.channel(NioServerSocketChannel.class);
  //注册一个ChannelInboundHandlerAdapter类型处理channel的连接
  bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
      //在channel的pipeline中加入消息处理类型为ChannelInboundHandlerAdapter
      ch.pipeline().addLast(new MessageChannel());
    }
  });
  //使用bind方法启动服务端的监听
  ChannelFuture future = bootstrap.bind(30888).sync();
  future.channel().closeFuture().sync();
  master.shutdownGracefully().sync();
}

public static class MessageChannel extends ChannelInboundHandlerAdapter {

  //处理消息
  @Override
  public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    //使用ByteBuf获取消息
    ByteBuf buf = (ByteBuf) msg;
    String message = buf.toString(CharsetUtil.UTF_8);
    System.out.println("Client message:" + message);
    //服务端写消息给客户端
    ctx.writeAndFlush(ctx.alloc().buffer().writeBytes(("Copy message:" + message).getBytes()));
    if ("bye".equalsIgnoreCase(message.replace("\n", ""))) {
      ctx.writeAndFlush(ctx.alloc().buffer().writeBytes("bye".getBytes()));
      //关闭连接
      ctx.close();
    }
  }

  //处理连接被激活的事件
  @Override
  public void channelActive(ChannelHandlerContext ctx) throws Exception {
    System.out.println("Client connect:" + ctx.channel().remoteAddress());
    super.channelActive(ctx);
    //写消息给客户端
    ctx.channel().writeAndFlush(Unpooled.copiedBuffer("Connect success!".getBytes()));
  }

 //处理异常，异常后关闭连接
  @Override
  public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
    super.exceptionCaught(ctx, cause);
    cause.printStackTrace();
    ctx.close();
  }
}

public static void main(String[] arg) throws InterruptedException {
  NioEventLoopGroup group=new NioEventLoopGroup()
  Bootstrap bootstrap = new Bootstrap();
  bootstrap.channel(NioSocketChannel.class);
  bootstrap.group(group)
  bootstrap.option(ChannelOption.SO_KEEPALIVE,true);
  //绑定远程服务地址与端口
  bootstrap.remoteAddress("127.0.0.1", 30888);
  final MessageChannel channel = new MessageChannel();
  bootstrap.handler(new ChannelInitializer<SocketChannel>() {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
      ch.pipeline().addLast(channel);
    }
  });
  //连接远程服务器
  ChannelFuture channelFuture = bootstrap.connect().sync();
  channelFuture.channel().closeFuture().sync();
  group.shutdownGracefully();
}

@ChannelHandler.Sharable
  public static class MessageChannel extends SimpleChannelInboundHandler<ByteBuf> {
    //处理消息读
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
      System.out.println("Client received: " + msg.toString(CharsetUtil.UTF_8));
    }

    //处理连接信息
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
      System.out.println("正在连接...");
      //主动发送一条消息至远程服务器
      ctx.channel().write(Unpooled.copiedBuffer("客户端的消息\n".getBytes()));
      //冲刷消息
      ctx.channel().flush();
      super.channelActive(ctx);
    }

    //处理连接关闭事件
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
      System.out.println("连接关闭...");
      super.channelInactive(ctx);
    }
		//处理异常，异常时关系channel
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
      super.exceptionCaught(ctx, cause);
      cause.printStackTrace();
      ctx.close();
    }
  }