RPC框架设计(三)-Netty核心原理

最新推荐文章于 2023-04-19 18:51:06 发布
最新推荐文章于 2023-04-19 18:51:06 发布
阅读量185 收藏
点赞数
分类专栏： 自定义RPC 文章标签： netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013215565/article/details/116497354
版权

3.Netty核心原理

3.1 Netty介绍

3.1.1 原生NIO存在的问题

1.NIO的类库和API繁杂，使用麻烦：需要熟练掌握Selector、ServerSocketChannel、SocketChannel、ByteBuffer等。
2.需要具备其他的额外技能：需要熟悉Java多线程编程，因为NIO编程涉及到Reactor模式，必须对多线程和网络编程非常熟悉，才能编写出高质量的NIO程序。
3.开发工作量和难度都非常大：例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常流的处理等等。
4.JDK NIO的Bug：臭名昭著的Epoll Bug，它会导致Selector空轮询，最终导致CPU100%。直到JDK 1.7版本该问题依旧存在，没有被根本解决。

在NIO中通过Selector的轮询当前是否有IO事件，根据JDK NIO api描述，Selector的select方法会一直阻塞，
直到IO事件达到或超时，但是在Linux平台上这里有时会出现问题，在某些场景下select方法会直接返回，
即使没有超时并且也没有IO事件到达，这就是著名的epollbug，这是一个比较严重的bug，它会导致线程陷入死循环，
会让CPU飙到100%，极大地影响系统的可靠性，到目前为止，JDK都没有完全解决这个问题。

3.1.2 概述

  Netty 是由 JBOSS 提供的一个 Java 开源框架。Netty提供异步的、基于事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络IO程序。Netty是一个基于NIO的网络编程框架，使用Netty可以帮助你快速，简单的开发出一个网络应用，相当于简化和流程化了NIO的开发过程。作为当前最流行的NIO框架、Netty在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，知名的Elasticsearch、Dubbo框架内部都采用了Netty。
在这里插入图片描述
  从图中就能看出Netty的强大之处：零拷贝、可扩展事件模型；支持TCP、UDP、HTTP、WebSocket等协议；提供安全传输、压缩、大文件传输、编解码支持等等。

具备如下优点：
  1.设计优雅，提供阻塞和非阻塞的Socket；提供灵活可扩展的事件模型；提供高度可定制的线程模型。
  2.具备更高的性能和更大的吞吐量，使用零拷贝技术最小化不必要的内存复制，减少资源的消耗。
  3.提供安全传输特性。
  4.支持多种主流协议；预置多种编解码功能，支持用户开发私有协议。

3.2 线程模型

3.2.1 线程模型基本介绍

  不同的线程模式，对程序的性能有很大影响，在学习Netty线程模式之前，首先讲解下各个线程模式，最后看看Netty线程模型有什么优越性，目前存在的线程模型有：

  • 传统阻塞I/O服务模型
  • Reactor模型
    根据Reactor的数量和处理资源池现成的数量不同，有3中典型的实现：
    • 单Reactor单线程
    • 单Reactor多线程
    • 主从Reactor多线程

3.2.2 传统阻塞I/O服务模型

采用阻塞I/O模式获取输入的数据，每个连接都需要独立的线程完成数据的输入，业务处理和数据返回工作。
在这里插入图片描述
存在问题：
  1.当并发数很大，就会创建大量的线程，占用很大系统资源
  2.连接创建后，如果当前线程暂时没有数据可读，该线程会阻塞在read操作，造成线程资源浪费

3.2.3 Reactor模型

  Reactor模式，通过一个或多个输入同事传递给服务处理器的模式，服务器端程序处理传入的多个请求，并将它们同步分派到响应的处理过程，因此Reactor模式也叫Dispatcher模式。Reactor模式使用IO复用监听事件，收到时间后，分发给某个线程(进程)，这点就是网络服务器高并发处理关键。
1.单Reactor单线程
在这里插入图片描述

  • Selector是可以实现应用程序铜鼓一个阻塞对象监听多路连接请求
  • Reactor对象通过Selector监控客户端请求事件，收到事件后通过Dispatch进行分发
  • 建立连接请求事件，则由Acceptor通过Accept处理连接请求，然后创建一个Handler对象处理连接完成后的后续业务处理
  • Handler会完成Read->业务处理->Send的完整业务流程

优点：
  模型简单，没有多线程，进程通信、竞争的Entity，全部都在一个线程中完成
缺点：
  1.性能问题：只有一个线程，无法完全发挥多核CPU的性能。Handler在处理某个连接上的业务时，整个进程无法处理其他连接事件，很容易导致性能瓶颈
  2.可靠性问题：线程意外终止或者进入死循环，会导致整个系统通信模块不可用，不能接收和处理外部消息，造成节点故障

2.单Reactor多线程
在这里插入图片描述

  • Reactor对象通过Selector监控客户端请求事件，收到事件后，通过dispatch进行分发
  • 如果建立连接请求，则由Acceptor通过accept处理连接请求
  • 如果不是连接请求，则由reactor分发调用连接对应的handler来处理
  • handler只负责响应事件，不做具体的业务处理，通过read读取数据后，会分发给后面的woker线程池的某个线程处理业务
  • woker线程池会分配独立线程完成真正的业务，并将结果返回给handler
  • handler接收到响应后，通过send将结果返回给client

优点：
  可以充分的利用多核CPU的处理能力
缺点：
  多线程数据共享和访问比较复杂，reactor处理所有事件的监听和响应，在单线程运行，在高并发场景容易出现性能瓶颈

3.主从Reactor多线程
在这里插入图片描述

  • Reactor主线程MainReactor对象通过select监听客户端连接事件，收到事件后，通过Acceptor处理客户端连接事件
  • 当Acceptor处理完客户端连接事件后（与客户端建立好Socket连接），MainReactor将连接分配给SubReactor。（即：MainReactor只负责监听客户端连接请求，和客户端建立连接之后将连接交由SubReactor监听后面的IO事件。）
  • SubReactor将连接加入到自己的连接队列进行监听，并创建Handler对各种事件进行处理
  • 当连接上有新事件发生的时候，SubReactor就会调用对应的Handler处理
  • Handler铜鼓oread从连接上读取请求数据，将请求数据分发给Worker线程池进行业务处理
  • Worker线程池会分配独立线程来完成真正的业务处理，并将处理结果返回给Handler。Handler通过send向客户端发送响应数据
  • 一个MainReactor可以对应多个SubReactor，即一个MainReactor线程可以对应多个SubReactor线程

优点：
  1.MainReactor线程与SubReactor线程的数据交互简单、职责明确，MainReactor线程只需要接受新连接，SubReactor线程完成后续的业务处理
  2.MainReactor线程SubReactor线程的数据交互简单，MainReactor线程只需要把新连接传给SubReactor线程，SubReactor线程无需返回数据
  3.多个SubReactor线程能够应对更高的并发请求

缺点：
  这种模式的缺点是编程复杂度较高。但是由于其优点明显，在许多项目中被广泛使用，包括Nginx、Memcached、Netty等。这种模式也被叫做服务器的1+M+N线程模式，即使用该模式开发的服务器包含一个（或多个，1只是表示相对较少）连接建立线程+M个IO线程+N个业务处理线程。这是业界成熟的服务器程序设计模式。

3.2.4 Netty线程模型

  Netty的设计主要基于主从Reactor多线程模式，并做了一定的改进。
1.简单版Netty模型
在这里插入图片描述

  • BossGroup线程维护Selector，ServerSocketChannel注册到这个Selector上，只关注连接请求事件（主Reactor）
  • 当接收到来自客户端的连接建立请求事件的时候，通过ServerSocketChannel.accept方法获得对应的SocketChannel，并封装成NioSocketChannel注册到WorkerGroup线程中的Selector，每个Selector运行在一个线程中（从Reactor）
  • 当WorkerGroup线程中的Selector监听到自己感兴趣的IO事件后，就调用Handler进行处理

2.进阶版Netty模型
在这里插入图片描述

  • 有两组鲜橙汁：BossGroup和WorkerGroup，BossGroup中的线程专门负责和客户端建立连接，WorkerGroup中的线程专门负责处理连接上的读写
  • BossGroup和WorkerGroup含有多个不断循环的执行事件处理的线程，每个线程都包含一个Selector，用于监听注册在其上的Channel
  • 每个BossGroup中的线程循环执行以下三个步骤
    • 轮询注册在其上的ServerSocketChannel的accept事件（OP_ACCEPT事件）
    • 处理accept事件，与客户端建立连接，生成一个NioSocketChannel，并将其注册到WorkerGroup中某个线程上的Selector上
    • 再去一次循环任务队列中的下一个事件
  • 每个WorkerGroup中的线程循环执行以下三个步骤
    • 轮询注册在其上的NioSocketChannel的read/write事件（OP_READ/OP_WRITE事件）
    • 在对应的NioSocketChannel上处理read/write事件
    • 再去以此循环处理任务队列中的下一个事件

3.详细版Netty模型
在这里插入图片描述

  • Netty抽象出两组线程池：BossGroup和WorkerGroup，也可以叫做BossNIOEventLoopGroup和WorkerNIOEventLoopGroup。每个线程池中都有NioEventLoop线程。BossGroup中的线程专门负责和客户端建立连接，WorkerGroup中的线程专门负责处理连接上的读写。BossGroup和WorkerGroup的类型都是NioEventLoopGroup
  • NioEventLoopGroup相当于一个事件循环组，这个组中含有多个事件循环，每个事件循环就是一个NioEventLoop
  • NioEventLoop标识一个不断循环的执行事件处理的线程，每个NioEventLoop都包含一个Selector，用于监听注册在其上的Socket网络连接（Channel）
  • NioEventLoopGroup可以包含多个线程，即可以含有多个NioEventLoop
  • 每个BossNioEventloop中循环执行以下三个步骤
    • select：轮询注册在其上的ServerSocketChannel的accept事件（OP_ACCEPT事件）
    • processSelectedKeys：处理accept事件，与客户端建立连接，生成一个NioSocketChannel，并将其注册到某个WorkerNioEventLoop上的Selector上
    • runAllTasks：再去以此循环处理任务队列中的其他任务
  • 每个WorkerNioEventLoop中循环执行以下三个步骤
    • select：轮询注册在其上的NioSocketChannel的read/write事件（OP_READ/OP_WRITE事件）
    • processSelectedKeys：在对应的NioSocketChannel上处理read/write事件
    • runAllTasks：再去以此循环处理任务队列中的其他任务
  • 在以上两个processSelectedKeys步骤中，会使用Pipeline（管道），Pipeline中引用了Channel，即通过Pipeline可以获取到对应的Channel，Pipeline中维护了很多的处理器（拦截处理器、过滤处理器、自定义处理器等）。

3.3 核心API介绍

3.3.1 ChannelHandler及其实现类

ChannelHandler接口定义了许多事件处理的方法，我们可以通过重写这些方法区实现具体的业务逻辑。API关系如下图所示
在这里插入图片描述
  Netty开发中需要自定义一个 Handler 类去实现 ChannelHandle接口或其子接口或其实现类，然后通过重写相应方法实现业务逻辑，我们接下来看看一般都需要重写哪些方法

  • public void channelActive(ChannelHandlerContext ctx)，通道就绪事件
  • public void channelRead(ChannelHandlerContext ctx, Object msg)，通道读取数据事件
  • public void channelReadComplete(ChannelHandlerContext ctx) ，数据读取完毕事件
  • public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)，通道发生异常事件

3.3.2 ChannelPipeline

  ChannelPipeline是一个Handler的集合，他负责处理和拦截inbound或者outbound的事件和操作，相当于一个贯穿Netty的责任链
在这里插入图片描述
  如果客户端和服务器的Handler是一样的，消息从客户端到服务端或者反过来，每个Inbound类型或Outbound类型的Handler只会经过一次，混合类型的Handler（实现了Inbound和Outbound的Handler）会经过两次。准确的说ChannelPipeline中是一个ChannelHandlerContext,每个上下文对象中有ChannelHandler. InboundHandler是按照Pipleline的加载顺序的顺序执行, OutboundHandler是按照Pipeline的加载顺序，逆序执行

3.3.3 ChannelHandlerContext

  这 是 事 件 处 理 器 上 下 文 对 象 ， Pipeline 链 中 的 实 际 处 理 节 点 。 每 个 处 理 节 点ChannelHandlerContext 中 包 含 一 个 具 体 的 事 件 处 理 器 ChannelHandler ,同时ChannelHandlerContext 中也绑定了对应的 ChannelPipeline和 Channel 的信息，方便对ChannelHandler 进行调用。常用方法如下所示：

  • ChannelFuture close()，关闭通道
  • ChannelOutboundInvoker flush()，刷新
  • ChannelFuture writeAndFlush(Object msg) ， 将 数 据 写 到 ChannelPipeline 中 当 前ChannelHandler 的下一个 ChannelHandler 开始处理

3.3.4 ChannelOption

  Netty 在创建 Channel 实例后,一般都需要设置 ChannelOption 参数。ChannelOption 是 Socket 的标准参数，而非 Netty 独创的。常用的参数配置有：

  • ChannelOption.SO_BACKLOG
    对应 TCP/IP 协议 listen 函数中的 backlog 参数，用来初始化服务器可连接队列大小。服务端处理客户端连接请求是顺序处理的，所以同一时间只能处理一个客户端连接。多个客户 端来的时候，服务端将不能处理的客户端连接请求放在队列中等待处理，backlog 参数指定 了队列的大小。
  • ChannelOption.SO_KEEPALIVE
    一直保持连接活动状态。该参数用于设置TCP连接，当设置该选项以后，连接会测试链接的状态，这个选项用于可能长时间没有数据交流的连接。当设置该选项以后，如果在两小时内没有数据的通信时，TCP会自动发送一个活动探测数据报文。

3.3.5 ChannelFuture

  表示 Channel 中异步 I/O 操作的结果，在 Netty 中所有的 I/O 操作都是异步的，I/O 的调用会直接返回，调用者并不能立刻获得结果，但是可以通过 ChannelFuture 来获取 I/O 操作 的处理状态。
常用方法如下所示：

  • Channel channel()，返回当前正在进行 IO 操作的通道
  • ChannelFuture sync()，等待异步操作执行完毕,将异步改为同步

3.3.6 EventLoopGroup和实现类NioEventLoopGroup

  EventLoopGroup 是一组 EventLoop 的抽象，Netty 为了更好的利用多核 CPU 资源，一般 会有多个EventLoop 同时工作，每个 EventLoop 维护着一个 Selector 实例。
  EventLoopGroup 提供 next 接口，可以从组里面按照一定规则获取其中一个 EventLoop 来处理任务。在 Netty 服务器端编程中，我们一般都需要提供两个 EventLoopGroup，例如：BossEventLoopGroup 和 WorkerEventLoopGroup。 通常一个服务端口即一个 ServerSocketChannel对应一个Selector 和一个EventLoop线程。 BossEventLoop 负责接收客户端的连接并将SocketChannel 交给 WorkerEventLoopGroup 来进 行 IO 处理，如下图所示：
在这里插入图片描述
  BossEventLoopGroup 通常是一个单线程的 EventLoop，EventLoop 维护着一个注册了ServerSocketChannel 的 Selector 实例，BossEventLoop 不断轮询 Selector 将连接事件分离出来， 通常是 OP_ACCEPT 事件，然后将接收到的 SocketChannel 交给 WorkerEventLoopGroup，WorkerEventLoopGroup 会由 next 选择其中一个 EventLoopGroup 来将这个 SocketChannel 注册到其维护的 Selector 并对其后续的 IO 事件进行处理。
一般情况下我们都是用实现类NioEventLoopGroup.
常用方法如下所示：

  • public NioEventLoopGroup()，构造方法,创建线程组
  • public Future<?> shutdownGracefully()，断开连接，关闭线程

3.3.7 ServerBootstrap和Bootstrap

  ServerBootstrap 是 Netty 中的服务器端启动助手，通过它可以完成服务器端的各种配置；
Bootstrap 是 Netty 中的客户端启动助手，通过它可以完成客户端的各种配置。常用方法如下 所示：

  • public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroupchildGroup)， 该方法用于服务器端，用来设置两个 EventLoop
  • public B group(EventLoopGroup group) ，该方法用于客户端，用来设置一个 EventLoop
  • public B channel(Class<? extends C> channelClass)，该方法用来设置一个服务器端的通道 实现
  • public B option(ChannelOption option, T value)，用来给 ServerChannel 添加配置
  • public ServerBootstrap childOption(ChannelOption childOption, T value)，用来给接收到的通道添加配置
  • public ServerBootstrap childHandler(ChannelHandler childHandler)，该方法用来设置业务 处理类（自定义的 handler)
  • public ChannelFuture bind(int inetPort) ，该方法用于服务器端，用来设置占用的端口号
  • public ChannelFuture connect(String inetHost, int inetPort) ，该方法用于客户端，用来连 接服务器端

3.3.8 Unpooled类

这是 Netty 提供的一个专门用来操作缓冲区的工具类，常用方法如下所示：

  • public static ByteBuf copiedBuffer(CharSequence string, Charset charset)，通过给定的数据 和字符编码返回一个 ByteBuf 对象（类似于 NIO 中的 ByteBuffer 对象）

3.4 Netty入门案例

  Netty 是由 JBOSS 提供的一个 Java 开源框架,所以在使用得时候首先得导入Netty的maven坐标

<dependency>
	<groupId>io.netty</groupId>
	<artifactId>netty-all</artifactId>
	<version>4.1.42.Final</version>
</dependency>

3.4.1 Netty服务端编写

服务端实现步骤:

  1. 创建bossGroup线程组: 处理网络事件–连接事件
  2. 创建workerGroup线程组: 处理网络事件–读写事件
  3. 创建服务端启动助手
  4. 设置bossGroup线程组和workerGroup线程组
  5. 设置服务端通道实现为NIO
  6. 参数设置
  7. 创建一个通道初始化对象
  8. 向pipeline中添加自定义业务处理handler
  9. 启动服务端并绑定端口,同时将异步改为同步
  10. 关闭通道和关闭连接池
    代码实现:
package com.lagou.demo;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

/**
 * Netty服务端
 */
public class NettyServer {
    public static void main(String[] args) throws InterruptedException {
        //1. 创建bossGroup线程组: 处理网络事件--连接事件
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        //2. 创建workerGroup线程组: 处理网络事件--读写事件 2*处理器线程数
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        //3. 创建服务端启动助手
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        //4. 设置bossGroup线程组和workerGroup线程组
        serverBootstrap.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class) //5. 设置服务端通道实现为NIO
                .option(ChannelOption.SO_BACKLOG, 128)//6. 参数设置
                .childOption(ChannelOption.SO_KEEPALIVE, Boolean.TRUE)//6. 参数设置
                .childHandler(new ChannelInitializer<SocketChannel>() { //7. 创建一个通道初始化对象
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        //8. 向pipeline中添加自定义业务处理handler
                        ch.pipeline().addLast(new NettyServerHandler());
                    }
                });
        //9. 启动服务端并绑定端口,同时将异步改为同步
        ChannelFuture future = serverBootstrap.bind(9999);
        future.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if (future.isSuccess()) {
                    System.out.println("端口绑定成功!");
                } else {
                    System.out.println("端口绑定失败!");
                }
            }
        });
        System.out.println("服务端启动成功.");
        //10. 关闭通道(并不是真正意义上关闭,而是监听通道关闭的状态)和关闭连接池
        future.channel().closeFuture().sync();
        bossGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}

自定义服务端handle

package com.lagou.demo;

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

/**
 * 自定义处理Handler
 */
public class NettyServerHandler implements ChannelInboundHandler {

    /**
     * 通道读取事件
     *
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf byteBuf = (ByteBuf) msg;
        System.out.println("客户端发送过来的消息:" + byteBuf.toString(CharsetUtil.UTF_8));
    }


    /**
     * 通道读取完毕事件
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(Unpooled.copiedBuffer("你好.我是Netty服务端",
                CharsetUtil.UTF_8));//消息出站
    }

    /**
     * 通道异常事件
     *
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }

    @Override
    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {

    }

    @Override
    public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {

    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {

    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {

    }


    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {

    }

    @Override
    public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {

    }

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {

    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {

    }


}

3.4.2 Netty客户端编写

客户端实现步骤:

  1. 创建线程组
  2. 创建客户端启动助手
  3. 设置线程组
  4. 设置客户端通道实现为NIO
  5. 创建一个通道初始化对象
  6. 向pipeline中添加自定义业务处理handler
  7. 启动客户端,等待连接服务端,同时将异步改为同步
  8. 关闭通道和关闭连接池
    代码实现:
package com.lagou.demo;

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;

/**
 * 客户端
 */
public class NettyClient {
    public static void main(String[] args) throws InterruptedException {
        //1. 创建线程组
        EventLoopGroup group = new NioEventLoopGroup();
        //2. 创建客户端启动助手
        Bootstrap bootstrap = new Bootstrap();
        //3. 设置线程组
        bootstrap.group(group)
                .channel(NioSocketChannel.class)//4. 设置客户端通道实现为NIO
                .handler(new ChannelInitializer<SocketChannel>() { //5. 创建一个通道初始化对象
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        //6. 向pipeline中添加自定义业务处理handler
                        ch.pipeline().addLast(new NettyClientHandler());
                    }
                });
        //7. 启动客户端,等待连接服务端,同时将异步改为同步
        ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 9999).sync();
        //8. 关闭通道和关闭连接池
        channelFuture.channel().closeFuture().sync();
        group.shutdownGracefully();
    }
}

自定义客户端handle

package com.lagou.demo;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandler;
import io.netty.util.CharsetUtil;

/**
 * 客户端处理类
 */
public class NettyClientHandler implements ChannelInboundHandler {

    /**
     * 通道就绪事件
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ChannelFuture future = ctx.writeAndFlush(Unpooled.copiedBuffer("你好呀.我是Netty客户端",
                CharsetUtil.UTF_8));
        future.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                if (future.isSuccess()) {
                    System.out.println("数据发送成功!");
                } else {
                    System.out.println("数据发送失败!");
                }
            }
        });
    }

    /**
     * 通道读就绪事件
     *
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf byteBuf = (ByteBuf) msg;
        System.out.println("服务端发送的消息:" + byteBuf.toString(CharsetUtil.UTF_8));
    }


    @Override
    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {

    }

    @Override
    public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {

    }


    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {

    }


    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {

    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {

    }

    @Override
    public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {

    }

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {

    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {

    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

    }
}

3.5 Netty异步模型

3.5.1 基本介绍

  异步的概念和同步相对。当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的组件在完成后，通过状态、通知和回调来通知调用者。
在这里插入图片描述
  Netty 中的 I/O 操作是异步的，包括 Bind、Write、Connect 等操作会简单的返回一个ChannelFuture。调用者并不能立刻获得结果，而是通过 Future-Listener 机制，用户可以方便的主动获取或者通过通知机制获得IO 操作结果. Netty 的异步模型是建立在 future 和 callback 的之上的。callback 就是回调。重点说 Future，它的核心思想是：假设一个方法 fun，计算过程可能非常耗时，等待 fun 返回显然不合适。那么可以在调用 fun 的时候，立马返回一个 Future，后续可以通过 Future 去监控方法 fun 的处理过程(即 ： Future-Listener 机制)

3.5.2 Future和Future-Listener

1.Future
  表示异步的执行结果, 可以通过它提供的方法来检测执行是否完成，ChannelFuture 是他的一个子接口. ChannelFuture 是一个接口 ,可以添加监听器，当监听的事件发生时，就会通知到监听器
  当 Future 对象刚刚创建时，处于非完成状态，调用者可以通过返回的 ChannelFuture 来获取操作执行的状态， 注册监听函数来执行完成后的操作。
常用方法有:

  • sync 方法, 阻塞等待程序结果返回；
  • isDone 方法来判断当前操作是否完成；
  • isSuccess 方法来判断已完成的当前操作是否成功；
  • getCause 方法来获取已完成的当前操作失败的原因；
  • isCancelled 方法来判断已完成的当前操作是否被取消；
  • addListener 方法来注册监听器，当操作已完成(isDone 方法返回完成)，将会通知指定的监听器；如果Future 对象已完成，则通知指定的监听器
    2.Future-Listener 机制
    给Future添加监听器,监听操作结果
    代码实现:
ChannelFuture future = bootstrap.bind(9999);
future.addListener(new ChannelFutureListener() {
	@Override
	public void operationComplete(ChannelFuture future) throws Exception {
		if (future.isSuccess()) {
			System.out.println("端口绑定成功!");
		} else {
			System.out.println("端口绑定失败!");
		}
	}
});

ChannelFuture channelFuture = ctx.writeAndFlush(Unpooled.copiedBuffer("你好
呀,我是Netty客户端", CharsetUtil.UTF_8));
channelFuture.addListener(new ChannelFutureListener() {
	@Override
	public void operationComplete(ChannelFuture future) throws Exception {
		if (future.isSuccess()) {
			System.out.println("数据发送成功.");
		} else {
			System.out.println("数据发送失败.");
		}
	}
});
水水的搬砖工
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
老夫一把梭，Netty工作原理你必须要知道的事
QAQFyl的博客
01-29 425
1、架构设计 Netty 采用了比较典型的三层网络架构进行设计，逻辑架构图如下所示： 第一层：Reactor 通信调度层，它由一系列辅助类完成，包括 Reactor 线程 NioEventLoop 以及其父类、NioSocketChannel/NioServerSocketChannel 以及其父类、ByteBuffer 以及由其衍生出来的各种 Buffer、Unsafe 以及其衍生出的各种内部类等。该层的主要职责就是监听网络的读写和连接操作，负责将网络层的数据读取到内存缓冲区中，然后触..
Netty核心原理剖析与RPC实践pd手抄
05-27
Netty核心原理剖析与RPC实践手抄版本，基本复刻了全部内容，如有丢失请私聊
netty原理
James201904的博客
12-30 3579
Netty IO模型 java有三种IO模型 BIO,NIO,AIO 1. BIO 同步阻塞模型，一个客户端对应一个处理线程 main() { ServerSocket server = new ServerSocket(50000); while(true) { Socket client = server.accept(); //没有客户端连接会阻塞 handler(client); //通过socket读取client发来的数据 会阻塞读取 可以new
Netty核心原理
weixin_42386438的博客
04-16 4995
Netty
必会框架 - RPC与ORM（下）
Andrew.J
11-17 335
接上篇 详解 Netty 下面我们来看 Netty 相关的知识点，如下图所示。 特点 如上图左侧所示，首先了解 Netty 的特点。 ●Netty 是一个高性能的异步事件驱动的 NIO 框架，它对消息的处理采用串行无锁化设计，提供了对 TCP、UDP 和文件传输的支持。 ●Netty 内置了多种 encoder 和 decoder 实现来解决 TCP 粘包问题。 ●Netty 处理消息时使用了池化的缓冲池 ByteBufs，提高性能。 ●结合内存零 copy 机制，减少了对象的创建，降低了 GC 的压力。
Netty4.1实战-手写RPC框架.pdf
09-01
RPC是一种远程调用的通信协议，例如dubbo、thrift等，我们在互联网高并发应用开发时候都会使用到类似的服务。本专题主要通过三个章节实现一个rpc...- 手写RPC框架第二章《netty通信》 - 手写RPC框架第三章《RPC中间件》
reactor-netty-http-1.0.11-API文档-中文版.zip
06-04
赠送jar包：reactor-netty-http-1.0.11.jar； 赠送原API文档：reactor-netty-http-1.0.11-javadoc.jar； 赠送源代码：reactor-netty-http-1.0.11-sources.jar； 赠送Maven依赖信息文件：reactor-netty-...
reactor-netty-core-1.0.15-API文档-中文版.zip
05-09
赠送jar包：reactor-netty-core-1.0.15.jar； 赠送原API文档：reactor-netty-core-1.0.15-javadoc.jar； 赠送源代码：reactor-netty-core-1.0.15-sources.jar； 赠送Maven依赖信息文件：reactor-netty-core-1.0.15....
go-netty:受netty启发的可扩展网络应用程序框架
05-04
netty/go-netty""github.com/go-netty/go-netty/codec/format""github.com/go-netty/go-netty/codec/frame")func main () {// child pipeline initializervar childInitializer = func ( channel netty. Channel ) {...
netty3升级到4后由于线程模型的变化引起的问题
yine的专栏
09-10 2693
1｜Netty的特点 Netty入门比较简单，主要原因有如下几点： Netty的API封装比较简单，将复杂的网络通信通过BootStrap等工具类做了二次封装，用户使用起来比较简单；Netty源码自带的Demo比较多，通过Demo可以很快入门；Netty社区资料、相关学习书籍也比较多，学习资料比较丰富。 但是很多入门之后的Netty学习者遇到了很多困惑，例如不知道
Netty——深入理解主从 Reactor 多线程模式
weixin_57323780的博客
04-19 742
BossGroup 中的线程专门负责和客户端建立连接，WorkerGroup 中的线程专门负责处理连接上的读写。1）有两组线程池：BossGroup 和 WorkerGroup，BossGroup 中的线程（可以有多个，图中只画了一个）专门负责和客户端建立连接，WorkerGroup 中的线程专门负责处理连接上的读写。这种模式的优点是可以充分的利用多核 cpu 的处理能力，缺点是多线程数据共享和控制比较复杂，Reactor 处理所有的事件的监听和响应，在单线程中运行，面对高并发场景还是容易出现性能瓶颈。
NIO和Netty编程（一）之多线程编程
zengdongwen的博客
07-19 1287
1、基本知识回顾 线程是比进程更小的能独立运行的基本单位，它是进程的一部分，一个进程可以拥有多个线程，但至少要有一个线程，即主执行线程(Java 的main 方法)。我们既可以编写单线程应用，也可以编写多线程应用。一个进程中的多个线程可以并发(同时)执行，在一些执行时间长、需要等待的任务上（例如：文件读写和网络传输等），多线程就比较有用了。 怎么理解多线程呢？来两个例子： 1....
netty 重要原理分享
王温暖的博客
12-03 512
回顾linux网络IO 遗留问题 Netty特点 异步非阻塞通信 零拷贝 内存池 总结 内存分配流程 内存释放 个人看法 高效的 Reactor 线程模型 无锁化的串行设计理念 高效的并发编程 高性能的序列化框架 灵活的 TCP 参数配置能力 回顾linux网络IO 遗留问题 epoll 支持两种事件触发模式，分别是边缘触发（edge-triggered，ET）和水平触发（level-triggered，LT）.
一文理解Netty模型架构
weixin_34082789的博客
11-01 1189
作者 陈彩华 贝聊后端开发工程师 文章转载交流请联系 [email protected] 复制代码本文基于Netty4.1展开介绍相关理论模型，使用场景，基本组件、整体架构，知其然且知其所以然，希望给读者提供学习实践参考。 1 Netty简介 Netty是 一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。 JDK原生NIO程序的问题 JDK原生也有一套网络应用...
Netty工作原理最详细分析
u012325073的博客
10-31 1132
本文链接：https://blog.csdn.net/Peter_Changyb/article/details/82344739 Netty是Java程序员通向高阶之路必须要过的门槛之一。干了几年的Java程序员发现业务开发似乎就是在SSH的世界里摸滚打爬的时候，会开始感到迷茫，难道程序员的日子就是如此枯燥么？深入使用一下Netty，另一个世界的大门就会开始打开。枯燥的编码会渐渐变得有趣，...
Netty 原理
MayMatrix 的博客
05-20 271
版本说明 Netty3(3.x)版本是比较旧的版本。 Netty4(4.x)版本是当前官方推荐的，目前一直在维护中。跟3.x版本相比变化比较大，特别是API。 Netty5(5.x)是被舍弃的版本，官方不推荐使用！ Netty5舍弃的官方解释： 1. netty5 中使用了 ForkJoinPool，增加了代码的复杂度，但是对性能的改善却不明显 2. 多个分支的代码同步工作量很大 3. 作者觉得当下还不到发布一个新版本的时候 4. 在发布版本之前，还有更多问题需要调查一下，比如是否应该废弃
Netty学习一——Netty的通信原理
yx444535180的专栏
01-11 1020
在 Linux 的网络编程这个层次中，客户机和服务器各有一个Socket文件，当两台主机通信时，客户机里的客户端应用进程 A 发送消息，通过 TCP协议数据包头的 SYN 标志位置1，进行主动打开，经 A 主机的 TCP/IP 协议栈发送到 LAN，然后经 WAN 中的路由器传给服务端应用进程 B 的目的主机所在的 LAN，之后经目的主机的 LAN 将报文传给目的主机，最后经目的主机的 TCP/IP 协议栈处理，服务器被动打开，将消息递交给目的应用程序 B。下面的 demo 只一次调用，很简单。
Netty网络编程实战：基于Netty的Http服务器开发
大数据开发、JAVA开发、人工智能AI
02-22 570
Netty网络编程实战：基于Netty的Http服务器开发
netty核心原理剖析与rpc实践
最新发布
05-13
Netty是一个基于NIO的高性能网络通信框架，它的核心原理是通过事件驱动和异步处理机制来实现高效的网络传输。其特点是可扩展、可重用、易于维护、性能卓越。 RPC（Remote Procedure Call）是一种基于网络通信的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值