首页 星云 工具 资源 星选 资讯 热门工具
:

PDF转图片 完全免费 小红书视频下载 无水印 抖音视频下载 无水印 数字星空

认识netty的基本组件

编程知识
2024年07月30日 21:01

Java NIO VS Netty

有了 Java NIO,而且 Netty 也是基于 Java NIO 实现,那么为什么不能直接用 Java NIO 来实现网络通信模块呢? 接下来我解释一下原因。

如果我们用 Java NIO 来开发网络通信组件,势必会直接面对很多网络通信的问题。比如,网络连接异常如何处理、网络的闪断怎么处理、网络拥堵、拆包粘包等一大堆网络通信的问题。同时还会面临性能优化的问题,比如成熟的中间件为了提升通信性能,以及提升处理请求量,会设计成 reactor 模式。

所以,直接用 Java NIO 做通信模块,会有很多的生产环境的问题等待我们去处理,大部分经验并不是很资深的人是很难实现的。

但对比下来,Netty 开发通信组件则有很多优势。

  • 首先,Netty 简化了 Java NIO 的 API,封装了底层很多复杂的网络通细节,让我们开发程序变得很简单。
  • 其次,Netty 还提供了很多的高级功能,易于二次扩展。
  • 最重要的是,优秀的 Netty 设计实现了高性能、高并发、高吞吐、高可靠的网络通信。
  • 最后,大量的商业项目都使用了 Netty 作为网络通信模块,比如,Dubbo、RocketMQ。经过很多生产环境的验证后,Netty 可以说是 Java 软件里最成熟、最流行的网络通信模块。

但是 Netty 也是有劣势的,Netty 为了更好地封装 Java NIO 创造了很多抽象的概念,这些抽象概念对于初学者来说难度并不小。

总体来说,Netty 相对于 Java NIO 确实更加完善和健壮,但是也难于理解。

为了让你更好地理解 Netty,下面我会用 Netty 简单地实现一个有服务端和客户端的网络通信 Demo

Demo:Netty 入门程序

在这个 Demo 程序中,我会给大家详细解释程序中每步的意义,让大家更快地入门 Nettty 开发。

这里我会从服务端客户端这两端分别讲起。

服务端代码

服务端代码包括服务端启动类和处理网络事件的 Handler 类。启动类主要是一些 Netty 核心类的初始化及端口的绑定;Handler 类是用来处理网络事件对应的业务逻辑。

首先,服务端启动类 NettyServer 代码如下:

 
java
public class NettyServer {

    public static void main(String[] args) {
        // 第一步,分别创建两个处理网络的EventLoopGroup。
        EventLoopGroup parentGroup = new NioEventLoopGroup();   //Acceptor线程组
        EventLoopGroup childGroup = new NioEventLoopGroup();    //Processor或Handler 线程组

        try{
            // 第二步,初始化服务器
            ServerBootstrap serverBootstrap = new ServerBootstrap(); //相当于Netty服务器
            // 第三步,给服务器做一系列的配置。
            serverBootstrap
                    .group(parentGroup, childGroup)
                    .channel(NioServerSocketChannel.class)//监听端口的ServerSocketChannel
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .childHandler(new ChannelInitializer<SocketChannel>() { //处理每个连接的 SocketChannel,SocketChannel代表每一个连接
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(new NettyServerHandler()); //针对网络请求的处理逻辑
                        }
                    });
            System.out.println("Server 启动了");
            // 第四步,绑定端口。
            ChannelFuture channelFuture =  serverBootstrap.bind(50099).sync(); //监听指定端口
            // 第五步,等待服务器关闭
            channelFuture.channel().closeFuture().sync();// 同步等待关闭启动服务器的结果
        }catch (Exception ex){
            ex.printStackTrace();
        }finally {
            parentGroup.shutdownGracefully();
            childGroup.shutdownGracefully();
        }

    }
}
  • 第一步,需要创建两个 EventLoopGroup。EventLoopGroup 是来处理网络事件的,本质是个线程组,第一个 parentGroup 可以理解成 Reactor 模式里的 Acceptor,也就是接收网络事件的线程;但是 Acceptor 并不处理网络事件,会把网络事件交给 Processor 线程,在这里就是 childGroup 线程组。EventLoopGroup 是比较复杂的,本文后面部分会详细介绍。

  • 第二步,初始化服务器类 ServerBootstrap,也就是说 ServerBootstrap 代表服务器。

  • 第三步,给服务器类 ServerBootstrap 做一些必要的配置,包括前面定义的两个线程组作为初始化的参数,然后选取服务端处理连接的 NioServerSocketChannel。最后,也是最重要的,配置处理网络事件的类,这里我们定义了 NettyServerHandler 作为处理 SocketChannel 上的网络事件的类。这里,可以看到处理 SocketChannel 的类可以用链式调用,也就是这里的 pipeline(),这是一个很好的设计。

  • 第四步,服务端需要一个端口来对外提供服务,这里绑定的端口是 50099。

  • 第五步,等待服务器关闭。

我们接下来看看自定义的处理网络事件的类 NettyServerHandler 是怎么写的。

NettyServerHandler 这个类继承了 Netty 类库里提供的类 ChannelInboundHandlerAdapter 来实现业务操作。也就是说,Netty 已经把复杂的网络问题封装好了,我们只要关注数据处理就好了。处理网络事件的类 NettyServerHandler 代码如下:

 
java
 // 这个类很像 reactor 模式里的processor线程,负责读区请求然后返回响应
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 第一步,获取客户端请求的内容
        ByteBuf buffer= (ByteBuf) msg;
        byte[] requestBytes = new byte[buffer.readableBytes()];
        buffer.readBytes(requestBytes);
        
        String request = new String(requestBytes,"UTF-8");
        System.out.println("收到请求"+request);
        //第二步,向客户端返回信息
        String response = "收到请求后返回响应";
        ByteBuf responseBuffer = Unpooled.copiedBuffer(response.getBytes());
        ctx.write(responseBuffer);
    }

    @Override
    // 
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        // 真正的发送
        ctx.flush();
    }

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

    @Override
    // 只要channel打通了,就会执行
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("Server is Active......");
    }
}
  • 第一步,当有客户端向这个服务端发送请求时,服务端会发送网络读事件。这时会激发 channelRead() 的执行。首先初始化一个 byte 数组,然后从请求中读出二进制数据,最后转化成中文字符。
  • 第二步,调用方法 ctx.write(),把响应数据发到客户端。

但是需要说明的是,调用 ctx.write() 时并不代表数据已经发送了,因为操作系统要根据自己的实际情况发送数据。这时如果我们对一致性要求很高,就可以重载 channelReadComplete() 方法,并调用 ctx.flush() 方法,这样数据就能同步发送出去了。

当然还有别的方法比如 channelActive(),这个方法表示有客户端连接并且连接成功后 Channel 也是可用的。

结合上面两个类,上图:

好,服务端的程序就介绍完了,接下来介绍客户端的程序。

客户端代码

与服务端程序一样,客户端程序也分为启动类和处理网络事件的 Handler 类。

服务端启动类 NettyClient 代码如下:

 
java
public class NettyClient {
    public static void main(String[] args) {
        // 第一步,定义一个EventLoopGroup
        EventLoopGroup parent = new NioEventLoopGroup();   //Acceptor线程组
        try{
            Bootstrap bootstrap= new Bootstrap();
            // 第二步,对客户端做各种配置
            bootstrap.group(parent)
                    .channel(NioSocketChannel.class)
                    .option(ChannelOption.TCP_NODELAY,true)
                    .handler(new ChannelInitializer<Channel>() {
                        @Override
                        protected void initChannel(Channel channel) throws Exception {
                            channel.pipeline().addLast(new NettyClintHandler());
                        }
                    });
            //第三步,向服务端连接
            ChannelFuture channelFuture= bootstrap.connect("127.0.0.1",50099).sync();
            channelFuture.channel().closeFuture().sync();
        }catch (Exception ex){
            ex.printStackTrace();
        }
    }
}
  • 第一步,定义一个 EventLoopGroup,与服务端启动类不同的是,客户端启动类只定义了一个 EventLoopGroup 对象,而定义的这个对象就是分配连接事件的 Acceptor 线程。为什么是这样的设计?因为客户端的连接并不像服务端那样有成千上万的连接,网络事件少。所以,不需要 Acceptor 线程与 Processor 线程分开来分配不同的任务。

  • 第二步,定义一个启动类 Bootstrap,并对 Bootstrap 进行参数配置,比如说 Channel 用的是 NioSocketChannel (和服务器端用的不一样),同时也需要自定义一个 NettyClintHandler 来处理网络事件。

  • 第三步,向服务端请求连接。

接下来看看客户端处理网络事件的 Handler 类是如何写的。

处理网络事件的类 NettyClientHandler 代码如下:

 
java
public class NettyClintHandler extends ChannelInboundHandlerAdapter {
        // 第一步,定义要发送的内容
        private ByteBuf requestBuffer;
        
        public NettyClintHandler(){
            byte[] requestBytes = "发送请求".getBytes();
            requestBuffer = Unpooled.buffer(requestBytes.length);
            requestBuffer.writeBytes(requestBytes);
        }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
            // 第二步,向服务端发送消息
            ctx.writeAndFlush(requestBuffer);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
            // 第三步,读取服务端的响应
        ByteBuf responseBuffer = (ByteBuf) msg;
        byte[] responseBytes = new byte[responseBuffer.readableBytes()];
        responseBuffer.readBytes(responseBytes);

        String response = new String(responseBytes,"UTF-8");
        System.out.println("收到服务端的响应:"+response);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}
  • 第一步,定义客户端要向服务端发送的请求信息。

  • 第二步,当客户端对服务端的连接请求成功后,同时 channel 连接正常时,就会激发方法 channelActive() 的执行,在这个方法中我们通过调用 ctx.writeAndFlush(requestBuffer) 来发送请求。

  • 第三步,发送请求后,服务端会向客户端发送响应,这时会激发 channelRead() 方法的执行,我们可以读取响应。

到这里,用 Netty 实现服务端和客户端的代码就讲解完了,可以看到 Netty 把底层的 Java NIO 全部屏蔽掉了,我们只要关注配置参数,只关心业务实现类就可以了。

建议可以在本地尝试运行一下,这样理解地会更加深刻。

从代码中学习到的设计思想

  1. 网络功能和业务逻辑功能分离

首先,可以看到,负责通信模块的启动类和负责处理网络事件的 Handler 类是分开的,这样的好处是 Handler 类的业务逻辑功能和启动类的通信功能分离。功能分类的好处是显而易见的,这样做可以减少耦合

  1. 责任链设计模式

根据上述代码,对于网络事件的处理可以用多个 Handler 类对象处理。Netty 采用了链式调用来让各个 Handler 类对象串联起来。其实,这种设计也是为了减少耦合,我们可以对网络事件的处理分成几个步骤,每一个步骤由一个 Handler 负责。这样一方面做到了解耦,代表不同功能的 Handler 类互不影响。另一方面,我们对于某个 Channel 可以灵活地增加或减少处理它的 Hanlder。这样就会更加灵活便捷。

  1. 事件驱动

另外,事件驱动的思想也有很好的体现,在 Handler 类里有许多表示事件的方法,比如表示读事件的方法 channelRead(),表示 Channel 连接活跃的方法 channelActive()。事件驱动的好处是,代码会有很好的可读性,同时比较容易理解

总结

  • 首先,说明了 Netty 的使用场景。
  • 然后,讲述了 Java NIO 开发通信模块的一些问题,以及 Netty 开发通信模块的优势。
  • 之后,重点讲解了用 Netty 实现服务端和客户端的代码,让你对 Netty 的使用有个初步的体会,同时也对 Netty 相关的一些组件进行了讲解。
  • 最后,我们从代码例子中学到了一些很优秀的设计思想,比如,解耦、事件驱动。
From:https://www.cnblogs.com/aries-laosi/p/18333431
本文地址: http://www.shuzixingkong.net/article/614
0评论
提交 加载更多评论
其他文章 如何自动实现本地AD中禁用的用户从地址列表中隐藏掉?
我的博客园:https://www.cnblogs.com/CQman/ 如何自动实现本地AD中禁用的用户从地址列表中隐藏掉? 需求信息: 用户本地AD用户通过ADConnect同步到O365,用户想实现在本地已做同步的OU中禁用某一用户后,其可以自动实现把该用户从地址列表中隐藏掉。 用户的ADCo
如何自动实现本地AD中禁用的用户从地址列表中隐藏掉? 如何自动实现本地AD中禁用的用户从地址列表中隐藏掉? 如何自动实现本地AD中禁用的用户从地址列表中隐藏掉?
FP分数规划在无线通信中的应用
更多精彩内容请关注微信公众号 ‘优化与算法’ 前言 在数学优化中,分数规划是线性分式规划的推广。分数规划中的目标函数是两个函数的比值,这两个函数通常是非线性的。要优化的比值通常描述系统的某种效率。 1. Concave-convex FP问题 1.1 基本形式 一维问题。符号说明:用R表示实数集,用
FP分数规划在无线通信中的应用 FP分数规划在无线通信中的应用 FP分数规划在无线通信中的应用
[python] 启发式算法库scikit-opt使用指北
scikit-opt是一个封装了多种启发式算法的Python代码库,可以用于解决优化问题。scikit-opt官方仓库见:scikit-opt,scikit-opt官网文档见:scikit-opt-doc。 scikit-opt安装代码如下: pip install scikit-opt # 调用s
[python] 启发式算法库scikit-opt使用指北 [python] 启发式算法库scikit-opt使用指北 [python] 启发式算法库scikit-opt使用指北
AI/机器学习(计算机视觉/NLP)方向面试复习1
1.&#160;判断满二叉树 所有节点的度要么为0,要么为2,且所有的叶子节点都在最后一层。 #include &lt;iostream&gt; using namespace std; class TreeNode { public: int val; TreeNode* left; TreeNo
AI/机器学习(计算机视觉/NLP)方向面试复习1 AI/机器学习(计算机视觉/NLP)方向面试复习1
我用Awesome-Graphs看论文:解读X-Stream
这次向大家分享发表在SOSP 2013上的另一篇经典图计算框架论文X-Stream,构建了单机上基于外存的Scatter-Gather图处理框架。
我用Awesome-Graphs看论文:解读X-Stream 我用Awesome-Graphs看论文:解读X-Stream 我用Awesome-Graphs看论文:解读X-Stream
一款基于Fluent设计风格、现代化的WPF UI控件库
前言 今天大姚给大家分享一款基于Fluent设计风格、开源(MIT License)、现代化的WPF UI控件库,它提供直观的设计、主题、导航和全新的沉浸式控件,全部都是原生且无缝地集成在一起:WPF UI。 WPF介绍 WPF 是一个强大的桌面应用程序框架,用于构建具有丰富用户界面的 Window
一款基于Fluent设计风格、现代化的WPF UI控件库 一款基于Fluent设计风格、现代化的WPF UI控件库 一款基于Fluent设计风格、现代化的WPF UI控件库
《最新出炉》系列初窥篇-Python+Playwright自动化测试-59 - 判断元素是否显示 - 上篇
1.简介 有些页面元素的生命周期如同流星一闪,昙花一现。我们也不知道这个元素在没在页面中出现过,为了捕获这一美好瞬间,让其成为永恒。我们就来判断元素是否显示出现过。 在操作元素之前,可以先判断元素的状态。判断元素操作状态也可以用于断言。 2.常用的元素判断方法 2.1page对象调用的判断方法 pa
《最新出炉》系列初窥篇-Python+Playwright自动化测试-59 - 判断元素是否显示 - 上篇 《最新出炉》系列初窥篇-Python+Playwright自动化测试-59 - 判断元素是否显示 - 上篇 《最新出炉》系列初窥篇-Python+Playwright自动化测试-59 - 判断元素是否显示 - 上篇
一文带你了解CAP的全部特性,你学会了吗?
目录前言消息发布携带消息头设置消息前缀原生支持的延迟消息并行发布消息事务消息事务消息发送事务消息消费事务补偿消息处理序列化过滤器消息重试多线程处理自动恢复/重连分布式存储锁消息版本隔离优化的雪花算法消息自动清理消费者特性Attribute 订阅多Attribute 订阅通配符订阅异步订阅多程序集订阅
一文带你了解CAP的全部特性,你学会了吗? 一文带你了解CAP的全部特性,你学会了吗?