netty初识篇

最新推荐文章于 2024-07-31 20:40:14 发布

I_m_you_papa

最新推荐文章于 2024-07-31 20:40:14 发布

阅读量1k

点赞数 1

分类专栏： netty

原文链接：https://www.jianshu.com/p/9f330ebf872c

版权

netty 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

简介

官网简介

Netty is an asynchronous event-driven network application framework
for rapid development of maintainable high performance protocol servers & clients.

Netty是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。

不同类型IO和NIO

网络编程当然就少不了IO，所以需要熟悉一下IO基本知识。
下面总结了4种不同类型IO，如下图表。

4种不同IO

传统IO和NIO的区别

传统IO
如果你想用传统IO来处理多个socket的连接的话需要创建多个线程， 一个线程对应一个，具体反映如下图所示：

阻塞IO

NIO
而NIO的处理方式是通过多路复用的方式让一个线程去处理多个Socket，这样一来，只需要使用少量的线程就可以搞定多个socket了，线程只需要通过Selector去查一下它所管理的socket集合，哪个Socket的数据准备好了，就去处理哪个Socket，实现了资源最大利用。

非阻塞NIO

NIO特点主要体现：
1.使用较少的线程便可以处理许多连接，因此也减少了内存管理和上下文切换所带来的开销。
2.当没有IO操作需要处理的时候，线程也可以被用于其他任务。

I/O 复用模型

I/O 复用模型

在 I/O 复用模型中，会用到 Select，这个函数也会使进程阻塞，但是和阻塞 I/O 所不同的是这两个函数可以同时阻塞多个 I/O 操作。而且可以同时对多个读操作，多个写操作的 I/O 函数进行检测，直到有数据可读或可写时，才真正调用 I/O 操作函数。

为什么要用Netty

Netty是一个NIO客户端服务器框架，支持快速、简单地开发协议服务器和客户端等网络应用程序。它大大简化和流线网络编程，如TCP和UDP套接字服务器。
Netty经过精心设计，积累了许多协议(如FTP、SMTP、HTTP)的实现经验，以及各种二进制和基于文本的遗留协议。因此，Netty成功地找到了一种方法，在不妥协的情况下实现开发、性能、稳定性和灵活性。

Netty应用场景

暂时总结如下场景：

1.远程过程调用(RPC)，比如dubbo
2.聊天服务器。
3.弹幕服务器。
4.车联网等TCP层网络通讯。
5.Netty与MQTT协议打造LOT服务器。
6.网络游戏服务器。

其实netty和Spring作用非常相似，只是各自的领域不同。如果你是想用Java的TCP层操作选netty准没错。

Netty架构设计

Netty功能特性图

传输服务
支持BIO和NIO
容器集成
支持OSGI、JBossMC、Spring、Guice容器
协议支持
HTTP、Protobuf、二进制、文本、WebSocket等一系列常见协议都支持。
还支持通过实行编码解码逻辑来实现自定义协议
Core核心
可扩展事件模型、通用通信API、支持零拷贝的ByteBuf缓冲对象

Netty之helloworld

这里的代码来自于netty实战，我只是总结一下简单的流程。

客户端

EchoClient.java 是引导和启动客户端

运行流程：

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

public class EchoClient {

    private final String host;
    private final int port;


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


    /**
     * 运行流程：
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        new EchoClient("127.0.0.1",9090).start();
    }

    private void start() throws Exception {

        /**
         * Netty用于接收客户端请求的线程池职责如下。
         * （1）接收客户端TCP连接，初始化Channel参数；
         * （2）将链路状态变更事件通知给ChannelPipeline
         */
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.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());
                        }
                    });
            //绑定端口
            ChannelFuture f = b.connect().sync();

            f.channel().closeFuture().sync();
        } catch (Exception e) {
            group.shutdownGracefully().sync();
        }


    }
}

EchoClientHandler.java 客户端处理类


/**
 * 客户端处理类
 */
public class EchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {

    /**
     * 在到服务器的连接已经建立之后将被调用
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(Unpooled.copiedBuffer("Netty rocks !", CharsetUtil.UTF_8));
    }

    /**
     * 当从服务器接收到一个消息时被调用
     * @param channelHandlerContext
     * @param byteBuf
     * @throws Exception
     */
    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf) throws Exception {
        System.out.println("Client received: "+ byteBuf.toString(CharsetUtil.UTF_8));
    }

    /**
     * 在处理过程中引发异常时被调用
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

服务端

EchoServer 服务端

运行流程：

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

public class EchoServer {

    private final int port;

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


    public static void main(String[] args) throws Exception {
        new EchoServer(9090).start();
    }

    private void start() throws Exception {

        final EchoServerHandler serverHandler = new EchoServerHandler();
        /**
         * NioEventLoop并不是一个纯粹的I/O线程，它除了负责I/O的读写之外
         * 创建了两个NioEventLoopGroup，
         * 它们实际是两个独立的Reactor线程池。
         * 一个用于接收客户端的TCP连接，
         * 另一个用于处理I/O相关的读写操作，或者执行系统Task、定时任务Task等。
         */
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup childGroup = new NioEventLoopGroup();

        try {
            //ServerBootstrap负责初始化netty服务器，并且开始监听端口的socket请求
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, childGroup)
                    .channel(NioServerSocketChannel.class)
                    .localAddress(new InetSocketAddress(port))
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
//                            为监听客户端read/write事件的Channel添加用户自定义的ChannelHandler
                            socketChannel.pipeline().addLast(serverHandler);
                        }
                    });

            ChannelFuture f = b.bind().sync();

            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully().sync();
            childGroup.shutdownGracefully().sync();
        }
    }
}

EchoServerHandler 业务处理handler


/***
 * 服务端自定义业务处理handler
 */
public class EchoServerHandler extends ChannelInboundHandlerAdapter {

    /**
     * 对每一个传入的消息都要调用；
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

        ByteBuf in = (ByteBuf) msg;
        System.out.println("server received: "+in.toString(CharsetUtil.UTF_8));

        ctx.write(in);
    }


    /**
     * 通知ChannelInboundHandler最后一次对channelRead()的调用时当前批量读取中的的最后一条消息。
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        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();
        ctx.close();
    }
}

Netty中部分核心类说明

Bootstrap、ServerBootstrap

Bootstrap意思是引导，一个Netty应用通常由一个Bootstrap开始，主要作用是配置整个Netty程序，串联各个组件，Netty中Bootstrap类是客户端程序的启动引导类，ServerBootstrap是服务端启动引导类。

Future

Future提供了另外一种在操作完成是通知应用程序的方式。这个对象可以看作一个异步操作的结果占位符。通俗地讲，它相当于一位指挥官，发送了一个请求建立完连接，通信完毕了，你通知一声它回来关闭各项IO通道，整个过程，它是不阻塞的，异步的。
在Netty中所有的IO操作都是异步的，不能立刻得知消息是否被正确处理，但是可以过一会等它执行完成或者直接注册一个监听，具体的实现就是通过Future和ChannelFutures，他们可以注册一个监听，当操作执行成功或失败时监听会自动触发注册的监听事件。

Channel

Channel类似Socket，它代表一个实体（如一个硬件设备、一个网络套接字）的开放连接，如读写操作。通俗地讲，Channel字面意思就是通道，每一个客户端与服务端之间进行通信的一个双向通道。

Channel主要工作：

1.当前网络连接的通道的状态（例如是否打开？是否已连接？）
2.网络连接的配置参数（例如接收缓冲区大小）
3.提供异步的网络 I/O 操作(如建立连接，读写，绑定端口)，异步调用意味着任何 I/O 调用都将立即返回，并且不保证在调用结束时所请求的 I/O 操作已完成。调用立即返回一个 ChannelFuture 实例，通过注册监听器到ChannelFuture 上，可以 I/O 操作成功、失败或取消时回调通知调用方。
4.支持关联 I/O 操作与对应的处理程序。

不同协议、不同的阻塞类型的连接都有不同的 Channel 类型与之对应，下面是一些常用的 Channel 类型

NioSocketChannel，异步的客户端 TCP Socket 连接
NioServerSocketChannel，异步的服务器端 TCP Socket 连接
NioDatagramChannel，异步的 UDP 连接
NioSctpChannel，异步的客户端 Sctp 连接
NioSctpServerChannel，异步的 Sctp 服务器端连接
这些通道涵盖了 UDP 和 TCP网络 IO以及文件 IO.

EventLoop接口

NioEventLoop中维护了一个线程和任务队列，支持异步提交执行任务，线程启动时会调用NioEventLoop的run方法，执行I/O任务和非I/O任务：
I/O任务
即selectionKey中ready的事件，如accept、connect、read、write等，由processSelectedKeys方法触发。

非IO任务
添加到taskQueue中的任务，如register0、bind0等任务，由runAllTasks方法触发。

两种任务的执行时间比由变量ioRatio控制，默认为50，则表示允许非IO任务执行的时间与IO任务的执行时间相等。

ChannelHanndler

ChannelHandler是一个接口，处理I/O事件或拦截I/O操作，并将其转发到其ChannelPipeline(业务处理链)中的下一个处理程序。
ChannelHandler本身并没有提供很多方法，因为这个接口有许多的方法需要实现，方便使用期间，可以继承它的子类：

ChannelInboundHandler用于处理入站I/O事件
ChannelOutboundHandler用于处理出站I/O操作

或者使用以下适配器类：

ChannelInboundHandlerAdapter用于处理入站I/O事件
ChannelOutboundHandlerAdapter用于处理出站I/O操作
ChannelDuplexHandler用于处理入站和出站事件