[Java] Java搭建简单Netty开发环境入门教程

<!-- https://mvnrepository.com/artifact/io.netty/netty-all -->
  <dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.16.Final</version>
  </dependency>

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandler.Sharable;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;
 
@Sharable
public class EchoServerHandler extends ChannelInboundHandlerAdapter{
  @Override
  public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    //将客户端传入的消息转换为Netty的ByteBuf类型
    ByteBuf in = (ByteBuf) msg;
 
    // 在控制台打印传入的消息
    System.out.println(
        "Server received: " + in.toString(CharsetUtil.UTF_8)
    );
    //将接收到的消息写给发送者，而不冲刷出站消息
    ctx.write(in);
  }
 
  @Override
  public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
    // 将未处决消息冲刷到远程节点， 并且关闭该Channel
    ctx.writeAndFlush(Unpooled.EMPTY_BUFFER)
        .addListener(ChannelFutureListener.CLOSE);
  }
 
  /**
   * 异常处理
   * @param ctx
   * @param cause
   * @throws Exception
   */
  @Override
  public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
    //打印异常栈跟踪
    cause.printStackTrace();
 
    // 关闭该Channel
    ctx.close();
  }
}

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
 
import java.net.InetSocketAddress;
 
public class EchoServer {
  private final static int port = 8080;
 
  public static void main(String[] args) {
    start();
  }
 
  private static void start() {
    final EchoServerHandler serverHandler = new EchoServerHandler();
    // 创建EventLoopGroup
    EventLoopGroup bossGroup = new NioEventLoopGroup();
    EventLoopGroup workerGroup = new NioEventLoopGroup();
    // 创建EventLoopGroup
    ServerBootstrap b = new ServerBootstrap();
    b.group(bossGroup, workerGroup)
        //指定所使用的NIO传输Channel
    .channel(NioServerSocketChannel.class)
        //使用指定的端口设置套接字地址
    .localAddress(new InetSocketAddress(port))
        // 添加一个EchoServerHandler到Channle的ChannelPipeline
    .childHandler(new ChannelInitializer<SocketChannel>() {
      @Override
      protected void initChannel(SocketChannel socketChannel) throws Exception {
        //EchoServerHandler被标注为@shareable,所以我们可以总是使用同样的案例
        socketChannel.pipeline().addLast(serverHandler);
      }
    });
 
    try {
      // 异步地绑定服务器;调用sync方法阻塞等待直到绑定完成
      ChannelFuture f = b.bind().sync();
      // 获取Channel的CloseFuture，并且阻塞当前线程直到它完成
      f.channel().closeFuture().sync();
    } catch (InterruptedException e) {
      e.printStackTrace();
    } finally {
      // 优雅的关闭EventLoopGroup，释放所有的资源
      bossGroup.shutdownGracefully();
      workerGroup.shutdownGracefully();
    }
  }
}

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandler.Sharable;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.CharsetUtil;
 
@Sharable
public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {
  @Override
  public void channelActive(ChannelHandlerContext ctx) throws Exception {
    //当被通知Channel是活跃的时候，发送一条消息
    ctx.writeAndFlush(Unpooled.copiedBuffer("Netty rocks!", CharsetUtil.UTF_8));
  }
 
  @Override
  protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) throws Exception {
    System.out.println(
        "Client received: " + byteBuf.toString(CharsetUtil.UTF_8)
    );
  }
 
  @Override
  public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
    cause.printStackTrace();
    ctx.close();
  }
}

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
 
import java.net.InetSocketAddress;
 
public class EchoClient {
  private final static String HOST = "localhost";
  private final static int PORT = 8080;
 
  public static void start() {
    EventLoopGroup group = new NioEventLoopGroup();
    Bootstrap bootstrap = new Bootstrap();
    bootstrap.group(group)
        .channel(NioSocketChannel.class)
        .remoteAddress(new InetSocketAddress(HOST, PORT))
        .handler(new ChannelInitializer<SocketChannel>() {
          @Override
          protected void initChannel(SocketChannel socketChannel) throws Exception {
            socketChannel.pipeline().addLast(new EchoClientHandler());
          }
        });
    try {
      ChannelFuture f = bootstrap.connect().sync();
      f.channel().closeFuture().sync();
    } catch (InterruptedException e) {
      e.printStackTrace();
    }finally {
      group.shutdownGracefully();
    }
  }
 
  public static void main(String[] args) {
    start();
  }
}

Server received: Netty rocks!

Client received: Netty rocks!