Netty应用程序实战 - 被子里

公告

一、编写服务器

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

至少一个 ChannelHandler ——该组件实现了服务器对从客户端接收的数据的处理，即它的业务逻辑。
引导 ——这是配置服务器的启动代码。至少，它会将服务器绑定到它要监听连接请求的端口上。

1.ChannelHandler和业务逻辑

因为服务器会响应传入的消息，所以它需要实现ChannelInboundHandler 接口，用来定义响应入站事件的方法。这个简单的应用程序只需要用到少量的这些方法，所以继承Channel-InboundHandlerAdapter 类也就足够了，它提供了ChannelInboundHandler 的默认实现。

我们感兴趣的方法是：

channelRead() ——对于每个传入的消息都要调用；
channelReadComplete() ——通知ChannelInboundHandler 最后一次对channel-Read() 的调用是当前批量读取中的最后一条消息；

exceptionCaught() ——在读取操作期间，有异常抛出时会调用。

package com.liwai.study.netty;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;

/**
 * Sharable标示一个Channel- Handler可以被多个Channel安全地共享
 *
 * @author syp
 */
@ChannelHandler.Sharable
public class EchoServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        ByteBuf in = (ByteBuf) msg;
        System.out.println("Server received: " + 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();
        //关闭该Channel
        ctx.close();
    }
}

下面这些是关键点：

针对不同类型的事件来调用ChannelHandler ；
应用程序通过实现或者扩展ChannelHandler 来挂钩到事件的生命周期，并且提供自定义的应用程序逻辑；
在架构上，ChannelHandler 有助于保持业务逻辑与网络处理代码的分离。这简化了开发过程，因为代码必须不断地演化以响应不断变化的需求。

2.引导服务器

引导服务器本身的过程具体涉及以下内容：

绑定到服务器将在其上监听并接受传入连接请求的端口；
配置Channel ，以将有关的入站消息通知给EchoServerHandler 实例。

EchoServer 类的完整代码。

package com.liwai.study.netty;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
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.nio.NioServerSocketChannel;

import java.net.InetSocketAddress;

/**
 * @author syp
 */
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() +
                            " ");
        }
        //设置端口值（如果端口参数的格式不正确，则抛出一个NumberFormatException）
        int port = Integer.parseInt(args[0]);
        //调用服务器的start()方法
        new EchoServer(port).start();
    }

    public void start() throws Exception {
        final EchoServerHandler serverHandler = new EchoServerHandler();
        //创建Event-LoopGroup
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            //创建Server-Bootstrap
            ServerBootstrap b = new ServerBootstrap();
            b.group(group)
                    //指定所使用的NIO传输Channel
                    .channel(NioServerSocketChannel.class)
                    //使用指定的端口设置套接字地址
                    .localAddress(new InetSocketAddress(port))
                    //添加一个EchoServerHandler到子Channel的ChannelPipeline
                    .childHandler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(Channel ch) throws Exception {
                            ch.pipeline().addLast(serverHandler);
                            //EchoServerHandler被标注为 @Shareable，所以我们可以总是使用同样的实例
                        }
                    });
            //异步地绑定服务器；调用sync() 方法阻塞等待直到绑定完成
            ChannelFuture f = b.bind().sync();
            //获取Channel的CloseFuture，并且阻塞当前线程直到它完成
            f.channel().closeFuture().sync();
        } finally {
            //关闭EventLoopGroup，释放所有的资源
            group.shutdownGracefully().sync();
        }
    }
}

二、编写Echo客户端

客户端将会：

（1）连接到服务器；

（2）发送一个或者多个消息；

（3）对于每个消息，等待并接收从服务器发回的相同的消息；

（4）关闭连接。

1.通过ChannelHandler实现客户端逻辑

如同服务器，客户端将拥有一个用来处理数据的ChannelInboundHandler 。在这个场景下，你将扩展SimpleChannelInboundHandler 类以处理所有必须的任务。这要求重写下面的方法：

channelActive() ——在到服务器的连接已经建立之后将被调用；
channelRead0() ——当从服务器接收到一条消息时被调用；
exceptionCaught() ——在处理过程中引发异常时被调用。

package com.liwai.study.netty.client;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.util.CharsetUtil;

/**
 * 标记该类的实例可以被多个Channel共享
 *
 * @author syp
 */
@ChannelHandler.Sharable
public class EchoClientHandler extends
        SimpleChannelInboundHandler<ByteBuf> {
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        //当被通知Channel是活跃的时候，发送一条消息
        ctx.writeAndFlush(Unpooled.copiedBuffer("Netty rocks!", CharsetUtil.UTF_8));
    }

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

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

channelRead0() 方法。每当接收数据时，都会调用这个方法。需要注意的是，由服务器发送的消息可能会被分块接收。也就是说，如果服务器发送了5字节，那么不能保证这5字节会被一次性接收。即使是对于这么少量的数据，channelRead0() 方法也可能会被调用两次，第一次使用一个持有3字节的ByteBuf （Netty的字节容器），第二次使用一个持有2字节的ByteBuf 。作为一个面向流的协议，TCP保证了字节数组将会按照服务器发送它们的顺序被接收。

为什么我们在客户端使用的是SimpleChannelInboundHandler ，而不是在Echo- ServerHandler 中所使用的ChannelInboundHandlerAdapter 呢？这和两个因素的相互作用有关：业务逻辑如何处理消息以及Netty如何管理资源。

在客户端，当channelRead0() 方法完成时，你已经有了传入消息，并且已经处理完它了。当该方法返回时，SimpleChannelInboundHandler 负责释放指向保存该消息的ByteBuf 的内存引用。

在EchoServerHandler 中，你仍然需要将传入消息回送给发送者，而write() 操作是异步的，直到channelRead() 方法返回后可能仍然没有完成。为此，EchoServerHandler 扩展了ChannelInboundHandlerAdapter ，其在这个时间点上不会释放消息。

消息在EchoServerHandler 的channelReadComplete() 方法中，当writeAndFlush() 方法被调用时被释放

2.引导客户端

引导客户端类似于引导服务器，不同的是，客户端是使用主机和端口参数来连接远程地址，也就是这里的Echo服务器的地址，而不是绑定到一个一直被监听的端口

package com.liwai.study.netty.client;

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;

/**
 * @author syp
 */
public class EchoClient {
    private final String host;
    private final int port;

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

    public void start() throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            //创建Bootstrap
            //指定EventLoopGroup以处理客户端事件；需要适用于NIO的实现
            Bootstrap b = new Bootstrap();
            b.group(group)
                    //适用于NIO传输的Channel类型
                    .channel(NioSocketChannel.class)
                    //设置服务器的InetSocketAddr - ess
                    .remoteAddress(new InetSocketAddress(host, port))
                    //在创建Channel时，向ChannelPipeline中添加一个Echo-ClientHandler实例
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new EchoClientHandler());
                        }
                    });
            //连接到远程节点，阻塞等待直到连接完成
            ChannelFuture f = b.connect().sync();
            //阻塞，直到Channel关闭
            f.channel().closeFuture().sync();
        } finally {
            //关闭线程池并且释放所有的资源
            group.shutdownGracefully().sync();
        }
    }

    public static void main(String[] args) throws Exception {
        if (args.length != 2) {
            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();
    }
}

和之前一样，使用了NIO传输。注意，你可以在客户端和服务器上分别使用不同的传输。例如，在服务器端使用NIO传输，而在客户端使用OIO传输

让我们回顾一下这一节中所介绍的要点：

为初始化客户端，创建了一个Bootstrap 实例；
为进行事件处理分配了一个NioEventLoopGroup 实例，其中事件处理包括创建新的连接以及处理入站和出站数据；
为服务器连接创建了一个InetSocketAddress 实例；
当连接被建立时，一个EchoClientHandler 实例会被安装到（该Channel 的）ChannelPipeline 中；
在一切都设置完成后，调用Bootstrap.connect() 方法连接到远程节点；

参考书籍：《netty实战》

更多内容请关注微信公众号“外里科技”

posted on 2020-04-19 21:58 被子里阅读(13) 评论(0) 收藏举报来源

刷新页面返回顶部

beizili

公告