Netty 框架学习 —— 第一个 Netty 应用

2年前 (2022) 程序员胖胖胖虎阿

450 0 0

概述

在本文，我们将编写一个基于 Netty 实现的客户端和服务端应用程序，相信通过学习该示例，一定能更全面的理解 Netty API

该图展示的是多个客户端同时连接到一台服务器。客户端建立一个连接后，会向服务器发送一个或多个消息，反过来，服务器又会将每个消息回送给客户端

编写 Echo 服务器

所有 Netty 服务器都需要以下两部分：

至少一个 CHannelHandler

该组件实现了服务器对从客户端接收的数据的处理，即它的业务逻辑
引导

配置服务器的启动代码，将服务器绑定到它要监听连接请求的端口上

1. ChannelHandler 和业务逻辑

ChannelHandler 是一个接口族的父接口，它的实现负责接收并响应事件通知，即要包含数据的处理逻辑。我们的 Echo 服务器需要响应传入的消息，所以需要实现 ChannelHandler 接口，用来定义响应入站事件的方法，又因为只需要用到少量的方法，所以继承 ChannelHandlerAdapter 类就足够了，它提供了 ChannelHandler 的默认实现

我们感兴趣的方法有：

channelRead()

对于每个传入的消息都要调用
channelReadComplete()

通知 ChannelHandler 最后一次对 channelRead() 的调用是当前批量读取的最后一条消息
exceptionCaught

在读取操作期间，有异常抛出时会调用

Echo 服务器的 ChannelHandler 实现 EchoServerHandler 如下

@ChannelHandler.Sharable // 标识一个 ChannelHandler 可以被多个 Channel 安全的共享
public class EchoServerHandler extends ChannelHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf in = (ByteBuf) msg;
        System.out.println("Server receiver: " + in.toString(CharsetUtil.UTF_8));
        // 将接收到的消息写给发送者
        ctx.write(in);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
        // 将剩余的消息全部冲刷到远程结点，并关闭 CHannel
        ctx.writeAndFlush(Unpooled.EMPTY_BUFFER)
                .addListener(ChannelFutureListener.CLOSE);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        ctx.close();
    }
}

应用程序通过实现或者扩展 ChannelHandler 来挂钩到事件的生命周期，并且提供自定义的应用程序逻辑。ChannelHandler 有助于保持业务逻辑与网络处理代码的分离，简化了开发过程

2. 引导服务器

编写完 EchoServerHandler 实现的核心业务逻辑之后，我们现在探讨引导服务器的过程，具体涉及内容如下：

绑定服务器将在其上监听并接收传入连接请求的接口
配置 Channel，将入站消息交给 EchoServerHandler 实例

EchoServer 类完整代码如下

public class EchoServer {

    private final int port;

    public EchoServer(int port) {
        this.port = port;
    }

    public static void main(String[] args) throws Exception {
        if (args.length != 1) {
            System.err.println("Usage: " + EchoServer.class.getSimpleName() + " <port>");
            return;
        }
        int port = Integer.parseInt(args[0]);
        new EchoServer(port).start();
    }

    public void start() throws Exception {
        final EchoServerHandler serverHandler = new EchoServerHandler();
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(group)
                    // 指定所使用的 NIO 传输 Channel
                    .channel(NioServerSocketChannel.class)
                    // 使用指定的端口设置套接字地址
                    .localAddress(new InetSocketAddress(port))
                    // 添加一个 EchoServerHandler 到子 Handler 的 ChannelPipeline
                    .childHandler(new ChannelInitializer<>() {

                        @Override
                        protected void initChannel(Channel ch) {
                            ch.pipeline().addLast(serverHandler);
                        }
                    });
            // 异步地绑定服务器，调用 sync() 方法阻塞等待直到绑定完成
            ChannelFuture f = b.bind().sync();
            // 获取 Channel 的 CloseFuture，并且阻塞当前线程直到它完成
            f.channel().closeFuture().sync();
        } finally {
            // 关闭 EventLoopGroup 释放所有资源
            group.shutdownGracefully().sync();
        }
    }
}

到此为止，我们回顾一下服务器实现中的几个重要步骤：

EchoServerHandler 实现业务逻辑
main() 方法引导服务器

引导服务器过程的重要步骤如下：

创建一个 ServerBootstrap 的实例以引导和绑定服务器
创建并分配一个 NioEventLoopGroup 实例以进行事件的处理，如接受新连接以及读写数据
指定服务器绑定的本地的 InetSocketAddress
使用一个 EchoServerHandler 实例初始化每一个新的 Channel
调用 ServerBootstrap.bind() 方法以绑定服务器

编写 Echo 客户端

Echo 客户端的作用：

连接到服务器
发送一个或多个消息
对于每个消息，等待并接收从服务器返回的响应
关闭连接

和服务器一样，编写客户端所涉及的主要代码部分也是业务逻辑和引导

1. ChannelHandler 和客户端逻辑

客户端也要有一个用来处理数据的 ChannelHandler，这里选择 SimpleChannelInboundHandler 类处理所有必需的任务，要求重写下面的方法：

channelActive()

当与服务器的连接建立之后被调用
messageReceived()

当从服务器接收到一条消息时被调用
exceptionCaught()

在处理过程中引发异常时被调用

@ChannelHandler.Sharable
public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        // 当一个连接建立时被调用，发送一条消息
        ctx.writeAndFlush(Unpooled.copiedBuffer("Netty rocks!", CharsetUtil.UTF_8));
    }

    @Override
    protected void messageReceived(ChannelHandlerContext ctx, ByteBuf msg) {
        // 记录已接收消息的转储
        System.out.println("Client received: " + msg.toString(CharsetUtil.UTF_8));
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        // 发生异常时，记录错误并关闭 Channel
        cause.printStackTrace();
        ctx.close();
    }
}

2. 引导客户端

引导客户端类似于服务器，不同的是，客户端是使用主机和端口参数来连接远程地址

public class EchoClient {

    private final String host;
    private final int port;

    public EchoClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public static void main(String[] args) throws Exception {
        if (args.length != 1) {
            System.err.println("Usage: " + EchoClient.class.getSimpleName() + "<host> <port>");
            return;
        }
        String host = args[0];
        int port = Integer.parseInt(args[1]);
        new EchoClient(host, port).start();
    }

    public void start() throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            // 创建 Bootstrap
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .remoteAddress(new InetSocketAddress(host, port))
                    .handler(new ChannelInitializer<SocketChannel>() {

                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new EchoClientHandler());
                        }
                    });
            // 连接到远程节点，阻塞等待直到连接完成
            ChannelFuture future = bootstrap.connect().sync();
            // 阻塞，直到 Channel 关闭
            future.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully().sync();
        }
    }
}

到此为止，我们回顾一下客户端实现中的几个重要步骤：