Netty-尚硅谷（5. Netty模型）学习笔记

最新推荐文章于 2024-06-22 14:54:37 发布
最新推荐文章于 2024-06-22 14:54:37 发布
阅读量1.6k 收藏 14
点赞数 5
分类专栏： Netty 文章标签： netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44449838/article/details/109526887
版权

上一篇 ：4. 线程模型基本介绍

下一篇 ：6. 异步模型和HTTP示例

文章目录

1. Netty 工作原理示意图

  • Netty 主要基于主从 Reactors 多线程模型做了一定的改进，其中主从 Reactor 多 线程模型有多个 Reactor

1.1 简单版

在这里插入图片描述

  • 说明 ：
  1. BossGroup 线程维护Selector , 只关注Accecpt
  2. 当接收到Accept事件，获取到对应的 SocketChannel, 封装成 NIOScoketChannel并注册到 Worker 线程(事件循环), 并进行维护
  3. 当Worker线程监听到 Selector 中通道发生自己感 兴趣的事件后，就进行处理(就由 Handler 处理)， 注意 Handler 已经加入到通道

1.2 进阶版

在这里插入图片描述

1.3 详细版

在这里插入图片描述

  • 说明 ：
  1. Netty 抽象出两组线程池 BossGroup 专门负责接收客户端的连接, WorkerGroup 专门负责网络的读写
  2. BossGroup 和 WorkerGroup 类型都是 NioEventLoopGroup
  3. NioEventLoopGroup 相当于一个事件循环组, 这个组中含有多个事件循环 ，每一个事件循环是 NioEventLoop
  4. NioEventLoop 表示一个不断循环的执行处理任务的线程， 每个 NioEventLoop 都有一个 Selector , 用于监听绑定在其上的 Socket 的网络通讯
  5. NioEventLoopGroup(BossGroup、WorkerGroup) 可以有多个线程, 即可以含有多个 NioEventLoop
  6. 每个Boss 的 NioEventLoop 循环执行的步骤有3步
    1. 轮询accept 事件
    2. 处理accept 事件 , 与client建立连接 , 生成NioScocketChannel , 并将其注册到 Worker 的 NIOEventLoop 上的 Selector
    3. 处理任务队列的任务 ， 即 runAllTasks
  7. 每个 Worker 的 NIOEventLoop 循环执行的步骤
    1. 轮询read, write 事件
    2. 处理i/o事件， 即read , write 事件，在对应NioScocketChannel 处理
    3. 处理任务队列的任务 ， 即 runAllTasks
  8. 每个Worker NIOEventLoop 处理业务时，会使用 Pipeline(管道), Pipeline 中包含了 Channel , 即通过 Pipeline 可以获取到对应通道, 管道中维护了很多的处理器。管道可以使用 Netty 提供的，也可以自定义

2. Netty快速入门实例-TCP服务

  • 要求
  1. Netty 服务器在 6668 端口监听，客户端能发送消息给服务器 “hello, 服务器~”
  2. 服务器可以回复消息给客户端 “hello, 客户端~”
  • 代码实现

  1. 引入依赖

    <!--netty依赖-->
<dependency>
  <groupId>io.netty</groupId>
  <artifactId>netty-all</artifactId>
  <version>4.1.52.Final</version>
</dependency>

  2. 编写 Netty 的服务端 ：NettyServer

    public class NettyServer {
    public static void main(String[] args) throws InterruptedException {
        // 创建 BossGroup 和 WorkerGroup
        /*
            说明
            1. 创建两个线程组 BossGroup 和 WorkerGroup
            2. BossGroup 只处理连接请求
            3. WorkerGroup 处理真正客户端的业务
            4. 运行时，这两个都是无限循环
         */
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        // 进行异常处理，try - catch
        try {
            // 创建 服务端 启动对象，并配置参数
            ServerBootstrap bootstrap = new ServerBootstrap();
            // 使用链式编程进行配置参数
            bootstrap.group(bossGroup, workerGroup)// 设置两个线程组
                    .channel(NioServerSocketChannel.class)// 使用 NioServerSocketChannel 作为服务器的通道实现
                    .option(ChannelOption.SO_BACKLOG, 128)// 设置线程队列等待连接的个数
                    .childOption(ChannelOption.SO_KEEPALIVE, true)// 设置连接保持活动连接状态
                    .childHandler(new ChannelInitializer<SocketChannel>() {// 给 workerGroup 的 NioEventLoop 对应的管道（Pipeline）设置处理器
                        // 创建一个通道初始化对象
                        /**
                         * 向 workerGroup 对应的 管道（Pipeline） 设置处理器
                         *
                         * @param socketChannel
                         * @throws Exception
                         */
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline()// 获得 这个 socketChannel 对应的 Pipeline
                                    .addLast(new NettyServerHandler());// 把自定义的 Handler 添加到 管道
                        }
                    });
            System.out.println("服务器准备好了……");
            // 绑定一个端口，并且同步。生成了一个 ChannelFuture 对象
            // 这里就已经启动了服务器
            ChannelFuture channelFuture = bootstrap.bind(6668).sync();
            // 对 关闭通道 进行监听
            // 这里只是监听，只有关闭通道时才进行处理，这句话不是直接关闭了通道
            channelFuture.channel().closeFuture().sync();
        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }


    }
}

  3. 编写 自定义的 Netty 服务端处理器 ：NettyServerHandler

    /**
 * 1. 自定义一个 Handler 需要继承 Netty 规定好的某个 处理器适配器
 * 2. 这时自定义的 Handler ，才能称为一个 Handler
 */
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
    /** 读取数据的事件（可以读取客户端发送的消息）
     *
     * @param ctx 上下文对象，包含 管道、通道、地址
     * @param msg 客户端发送的消息，默认是 Object 类型
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("【Server】： ctx" + ctx);
        // 将 msg 转换成 ByteBuffer
        /*
            说明 :
            1. 注意这个是 ByteBuf ，是 io.netty.buffer 包下的，不是 NIO 下的 Buffer
            2. ByteBuf 比 Buffer 的性能更高一点
         */
        ByteBuf buf = (ByteBuf) msg;
        // 把 buf 转成 UTF8 格式的字符串
        System.out.println("客户端发送的 msg ：" + buf.toString(CharsetUtil.UTF_8));
        System.out.println("客户端地址 ：" + ctx.channel().remoteAddress());
    }

    /**
     * 数据读取完毕后，返回消息给客户端
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        // 把数据写入缓冲区，并刷新缓冲区
        // 一般来说，需要对这个发送的消息进行编码
        ctx.writeAndFlush(Unpooled.copiedBuffer("Hello,客户端",CharsetUtil.UTF_8));
    }

    /**
     * 处理异常
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        // 关闭通道
        ctx.channel().close();
    }
}

  4. 编写 Netty 的客户端 ：NettyClient

    public class NettyClient {
    public static void main(String[] args) throws InterruptedException {
        // 客户端需要一个事件循环组
        EventLoopGroup group = new NioEventLoopGroup();

        try {

            // 客户端启动对象 —— Bootstrap ，不是 服务端的 ServerBootstrap
            // 并且是 io.netty.bootstrap 包下的
            Bootstrap bootstrap = new Bootstrap();

            // 设置相关参数
            bootstrap.group(group)// 设置线程组
                    .channel(NioSocketChannel.class)// 设置客户端通道的实现类
                    .handler(new ChannelInitializer<SocketChannel>() {// 设置处理器
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast(new NettyClientHandler());// 加入自己的处理器
                        }
                    });
            System.out.println("客户端准备好了……");

            // 启动客户端连接服务器端
            // 这里涉及到一个 Netty 的异步模型,后面详述
            ChannelFuture channelFuture = bootstrap.connect("localhost", 6668).sync();
            // 对关闭通道进行监听
            channelFuture.channel().closeFuture().sync();
        }finally {
            group.shutdownGracefully();
        }

    }
}

  5. 编写 自定义的 Netty 客户端处理器 ：NettyClientHandler

    public class NettyClientHandler extends ChannelInboundHandlerAdapter {
    /**
     * 当通道就绪时，就会触发该方法，就可以发信息了
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("【Client】：ctx" + ctx);
        ctx.writeAndFlush(Unpooled.copiedBuffer("Hello,server", CharsetUtil.UTF_8));
    }

    /**
     * 当通道有读取事件时 ，会触发
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("服务器发送的 msg ：" + buf.toString(CharsetUtil.UTF_8));
        System.out.println("服务器的地址 ："+ ctx.channel().remoteAddress());
    }

    /**
     * 异常处理
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.channel().close();
    }
}

  • 启动测试

    先启动 NettyServer，在启动 NettyClient

    NettyServer 的控制台：
    在这里插入图片描述

    NettyClient 的控制台：
    在这里插入图片描述

3. 对‘Netty快速入门实例’的分析

  • 通过分析 ‘Netty快速入门实例’ 的执行流程，来熟悉并加深对 Netty模型 的理解

3.1 BossGroup 和 WorkGroup 怎么确定自己有多少个 NIOEventLoop

  1. 点进 NioEventLoopGroup
    在这里插入图片描述
    在这里插入图片描述

  2. 一直点进 this,一直进入父类
    在这里插入图片描述
    在这里插入图片描述

  3. 找到这个值的初始化代码
    在这里插入图片描述

  • 所以 BossGroup 和 WorkerGroup 含有的子线程数（NioEventLoop）默认为 CPU 核数*2

  • 在此处打一个断点，进行 Debug
    在这里插入图片描述

    在这里插入图片描述

  • 由源码中的构造方法可知 —— 想要设置线程数只要在参数中输入即可

3.2 WorkerGroup 是如何分配这些进程的

  • 设置 BossGroup 进程数为 1 ； WorkerGroup 进程数为 4 ； Client 数位 8

  • 设置进程数量
    在这里插入图片描述

  • 输出线程信息，在 NettyServerHandler 中添加
    在这里插入图片描述

  • 启动服务端、和4个客户端
    在这里插入图片描述

  • 启动第五个客户端会分配到哪个线程？
    在这里插入图片描述
    又回到了第一个线程，在默认情况下，WorkerGroup 分配的逻辑就是按顺序循环分配的

3.3 BossGroup 和 WorkerGroup 中的 Selector 和 TaskQueue

  • 打断点进行 Debug
    在这里插入图片描述
    在这里插入图片描述
  • 每个子线程都具有自己的 Selector、TaskQueue……

3.4 CTX 上下文、Channel、Pipeline 之间关系

  • 修改 NettyServerHandler ，并添加端点
    在这里插入图片描述
  • 先看 CTX 上下文中的信息
    在这里插入图片描述
    上下文中还有很多其他信息，就不一样列举了
  • Pipeline
    在这里插入图片描述
  • Channel
    在这里插入图片描述
  • CTX 上下文、Channel、Pipeline 三者关系示意图
    在这里插入图片描述

4. TaskQueue 任务队列

4.1 概述

  • 如果在某个 Handler 中有个长时间的操作，那势必会造成 Pipeline管道 的阻塞，那么这种情况就需要把这些任务提交到 TaskQueue 进行异步执行

  • TaskQueue 和 Channel 有绑定的关系

  • 任务队列中的 Task 有 3 种典型使用场景

  1. 用户程序自定义的普通任务
  2. 用户自定义定时任务
  3. 非当前 Reactor 线程调用 Channel 的各种方法

4.2 体验任务的阻塞

  1. 编写一个 服务端的 Handler ：NettyServerHandlerTaskQ

    public class NettyServerHandlerTaskQ extends ChannelInboundHandlerAdapter {
    /** 读取数据的事件（可以读取客户端发送的消息）
     *
     * @param ctx 上下文对象，包含 管道、通道、地址
     * @param msg 客户端发送的消息，默认是 Object 类型
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 比如这里有一个非常耗时的任务，希望可以异步执行
        // 把该任务提交到 Channel 对应的 NIOEventLoop 的 TaskQueue 中
        Thread.sleep(10 * 1000);
        ctx.writeAndFlush(Unpooled.copiedBuffer("Hello,客户端，这是一个执行耗时长的任务",CharsetUtil.UTF_8));
        System.out.println("耗时长的任务执行完毕，继续");
    }

    /**
     * 数据读取完毕后，返回消息给客户端
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(Unpooled.copiedBuffer("Hello,客户端",CharsetUtil.UTF_8));
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        // 关闭通道
        ctx.channel().close();
    }
}

  2. 修改 NettyServer 中添加到 Pipeline 的 Handler
    在这里插入图片描述

  3. 先这样执行一个查看效果（没有添加到任务队列）
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

4.3 TaskQueue 使用场景-1

  • 用户程序自定义的普通任务

  • 上面自定义了一个执行时间长的任务，该任务会阻塞这个 EventLoop 线程，可以使用该方法来解决耗时长的任务的阻塞问题

  • 修改 NettyServerHandlerTaskQ 中的 channelRead

    @Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
// 解决方案-1：用户程序自定义的普通任务
    ctx.channel().eventLoop().execute(()->{
        try {
            Thread.sleep(10 * 1000);
            ctx.writeAndFlush(Unpooled.copiedBuffer("Hello,客户端，这是一个执行耗时长的任务,方案-1",CharsetUtil.UTF_8));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    });
    System.out.println("耗时长的任务执行完毕，继续");
}

  • 运行测试
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  • 这也就能看出任务队列的异步执行了

  • 下断点，查看 TaskQueue

    在这里插入图片描述

    查看 ctx -> pipeline -> channel -> eventloop -> taskqueue
    在这里插入图片描述
    可以看到这里面有刚刚的 Handler

4.4 TaskQueue 使用场景-2

  • 用户自定义定时任务
  • 修改 NettyServerHandlerTaskQ 中的 channelRead
     @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
    // 解决方案-2：用户自定义定时任务
        // 把任务提交到 scheduledTaskQueue
        // 在和服务端连接成功后 5s 开始异步执行 run 方法
        ctx.channel().eventLoop().schedule(()->{
            try {
                Thread.sleep(5 * 1000);
                ctx.writeAndFlush(Unpooled.copiedBuffer("Hello,客户端，这是一个执行耗时长的任务,方案-2",CharsetUtil.UTF_8));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, 5, TimeUnit.SECONDS);
        
    	System.out.println("耗时长的任务执行完毕，继续");
    }
  • 运行测试
    在这里插入图片描述
    在这里插入图片描述
  • 下断点，查看 scheduledTaskQueue 中是否多了任务
    在这里插入图片描述

查看 ctx -> pipeline -> channel -> eventloop -> scheduledTaskQueue
在这里插入图片描述

4.5 TaskQueue 使用场景-3

  • 非当前 Reactor 线程调用 Channel 的各种方法

  • 例如：在推送系统的业务线程里面，根据用户的标识，找到对应的 Channel 引用，然后调用 Write 类方法向该用户推送消息，就会进入到这种场景。最终的 Write 会提交到任务队列中后被异步消费

  • 该场景就不演示了，只简单说一下思路

  1. 在用户连接到服务端的时候，可以获取到该客户对应的 SocketChannel 的 HashCode
    在这里插入图片描述

  2. 可以在服务端维护一个 集合 ，存放所有连接的 SocketChannel

  3. 在有消息需要推送的时候，就遍历这个 SocketChannel 集合，通过 HashCode 找到 Channel

  4. 通过 Channel 找到 EventLoop

  5. 再往后就是上面提到的任务的处理了

5. 总结

  1. Netty 抽象出两组线程池，BossGroup 专门负责接收客户端连接，WorkerGroup 专门负责网络读写操作。

  2. NioEventLoop 表示一个不断循环执行处理任务的线程，每个 NioEventLoop 都有一个 selector，用于监听绑定在其上的 socket 网络通道。

  3. NioEventLoop 内部采用串行化设计，从消息的 读取->解码->处理->编码->发送，始终由 IO 线程 NioEventLoop 负责

    • NioEventLoopGroup 下包含多个 NioEventLoop
    • 每个 NioEventLoop 中包含有一个 Selector，一个 taskQueue
    • 每个 NioEventLoop 的 Selector 上可以注册监听多个 NioChannel
    • 每个 NioChannel 只会绑定在唯一的 NioEventLoop 上
    • 每个 NioChannel 都绑定有一个自己的 ChannelPipeline

yuan_404
关注
  • 5
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
netty-netty-4.1.69.Final.tar.gz
10-20
这个“netty-netty-4.1.69.Final.tar.gz”文件是Netty的最新稳定版本，版本号为4.1.69.Final，它是一个压缩包文件，通常包含源码、编译后的类库、文档和其他相关资源。 Netty的核心特点包括： 1. **异步事件驱动**...
Netty笔记源码资料.rar
05-13
1.Netty 是由 JBOSS 提供的一个 Java 开源框架，现为 Github 上的独立项目。 2.Netty 是一个 异步的、 基于事件驱动的网络应用框架，用以快速开发高性能、高可靠性的网络 IO 程序。
搭建简单的Netty开发环境
热门推荐
Stormer的博客
10-23 2万+
今天准备学学声明显赫的Netty框架，自然要先学会怎么搭建一个简单的Netty开发环境啦。话不多说，下面进入正文。 编辑器方面自然是推荐IntelJ idea了，idea的强大不必多说，百度一下你就知道。哈哈 下面就是准备Netty的jar包了，如果你会maven的话自然是使用maven最为方便了。只需要在pom文件中导入以下几行 &lt;!-- https://mvnrepository...
什么是netty--通俗易懂
lisheng19870305的专栏
07-02 1万+
一．Netty介绍 1.什么是netty Netty是由JBOSS提供的一个Java开源框架。Netty提供异步的、基于事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络IO程序,是目前最流行的NIO框架，Netty在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，知名的Elasticsearch、Dubbo框架内部都采用了Netty。 2.为什么要用netty 原生NIO存在问题: 1.NIO的类库和API繁杂 2.需...
深入解析Netty的Reactor模型及其实现：详解与代码示例
最新发布
微笑听雨
06-22 4472
Netty是一个高性能、异步事件驱动的网络应用框架，采用了Reactor模型来实现高并发处理。Reactor模型是处理多路复用I/O操作的一种设计模式，它可以在一个或多个线程中调度多个I/O事件。本文将详细介绍Netty的Reactor模型及其在代码中的实现。
一文理解Netty模型架构
weixin_34082789的博客
11-01 1229
作者 陈彩华 贝聊后端开发工程师 文章转载交流请联系 caison@aliyun.com 复制代码本文基于Netty4.1展开介绍相关理论模型，使用场景，基本组件、整体架构，知其然且知其所以然，希望给读者提供学习实践参考。 1 Netty简介 Netty是 一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。 JDK原生NIO程序的问题 JDK原生也有一套网络应用...
Netty 介绍
木牛的博客
06-30 2924
1.1. Netty 原理Netty 是一个高性能、异步事件驱动的 NIO 框架，基于 JAVA NIO 提供的 API 实现。它提供了对TCP、UDP 和文件传输的支持，作为一个异步 NIO 框架，Netty 的所有 IO 操作都是异步非阻塞的，通过 Future-Listener 机制，用户可以方便的主动获取或者通过通知机制获得 IO 操作结果。1.2. Netty 高性能在 IO 编程过程中，当需要同时处理多个客户端接入请求时，可以利用多线程或者 IO 多路复用技术进行处理。IO 多路复用技术通过把多
尚硅谷Netty学习笔记
weixin_56870643的博客
01-01 1053
内容为Netty学习笔记，笔记采用多种颜色标识，清晰易读；对晦涩知识使用 2、NIO 非阻塞的实现原理 ​ NIO 通过其 Buffer 组件来实现非阻塞，线程非阻塞去处理别的通道（channel），未被线程处理的连接可以将数据继续写入 Buffer**非阻塞：可以做别的事，你要做的事最后还是要自己做**只是意味着方法调用不阻塞，就是说作为服务员的你不用一直在窗口等，非阻塞的逻辑是"等可以读（写）了告诉你"，但是完成读（写）工作的还是调用者（线程）服务员的你等菜到窗口了还是要你亲自去拿。异步：可以做别的事
netty-handler-4.1.68.Final-API文档-中文版.zip
06-04
赠送jar包：netty-handler-4.1.68.Final.jar； 赠送原API文档：netty-handler-4.1.68.Final-javadoc.jar； 赠送源代码：netty-handler-4.1.68.Final-sources.jar； 赠送Maven依赖信息文件：netty-handler-4.1.68....
netty-buffer-4.1.68.Final-API文档-中文版.zip
06-04
赠送jar包：netty-buffer-4.1.68.Final.jar； 赠送原API文档：netty-buffer-4.1.68.Final-javadoc.jar； 赠送源代码：netty-buffer-4.1.68.Final-sources.jar； 赠送Maven依赖信息文件：netty-buffer-4.1.68.Final....
Netty （netty-netty-4.1.77.Final.tar.gz）
06-07
Netty （netty-netty-4.1.77.Final.tar.gz）是一个 NIO 客户端服务器框架，可以快速轻松地开发协议服务器和客户端等网络应用程序。它极大地简化和流线了网络编程，例如 TCP 和 UDP 套接字服务器。 “快速和简单”并...
netty-handler-4.1.73.Final-API文档-中文版.zip
05-07
赠送jar包：netty-handler-4.1.73.Final.jar； 赠送原API文档：netty-handler-4.1.73.Final-javadoc.jar； 赠送源代码：netty-handler-4.1.73.Final-sources.jar； 赠送Maven依赖信息文件：netty-handler-4.1.73....
韩顺平老师所有课程笔记
04-13
本文档包含韩顺平老师的linux，Java，Oracle，PHP，struts,j2ee,javascript课程笔记
linux笔记(尚硅谷韩顺平linux笔记)
09-29
Linux笔记 配合我的博客使用 为我的博客Linux常用命令文本版
Netty全面解析
qq_45443475的博客
08-19 2672
Netty全面解析
Netty和Tomcat区别
weixin_42354735的博客
11-02 8577
Netty与Tomcat区别 它们的区别不少，最大的区别就在于通信协议，这是众所周知的，Tomcat是一个服务器，它一定是基于Http协议的，它的实质是一个基于http协议的web容器，Netty则不同，Netty可以通过编程自定义各种协议，这是因为netty能够通过codec自己来编码/解码字节流，完成一种类似redis访问的功能，这就是它们之间最大的不同。 事实上很多人都说netty的性能肯定比tomcat性能高，实际tomcat从6.x开始就一直支持nio模式，且后续还有arp模式，这是一种通过j
Netty
飘然生的博客
05-06 2092
Netty实战精髓篇 常见的网络通信框架？ Netty（JBoss） Mina（Apach） Grizzly（sum） 前言。BIO和NIO的通信流程区别 中间多插入一个多路复用器 BIO:服务端——线程——socket——客户端 （有几个客户端就有几个线程） NIO:服务端——线程——selector——socket——客户端 （一个线程，一个多路复用器进行轮询） 一。...
尚硅谷-netty笔记
weixin_44801482的博客
05-12 2395
1：简介 Netty 是由 JBOSS 提供的一个 Java 开源框架，现为 Github上的独立项目。 Netty 是一个异步的、基于事件驱动（客户端的行为、读写事件）的网络应用框架，用以快速开发高性能、高可靠性的网络 IO 程序。 Netty主要针对在TCP协议下，面向Clients端的高并发应用，或者Peer-to-Peer场景下的大量数据持续传输的应用。 Netty本质是一个NIO框架，适用于服务器通讯相关的多种应用场景 要透彻理解Netty ， 需要先学习 NIO ， 这样我们才能阅读 Netty
尚硅谷韩顺平Netty学习笔记-Netty概述
qq_20314141的博客
01-02 1028
Netty是由JBOSS提供的一个Java开源框架，现为Github上的独立项目Netty是一个异步的、基于事件驱动的网络应用框架，用以快速开发高性能、高可靠性的网络IO程序Netty主要针对在TCP协议下，面向Clients端的高并发应用，或者场景下的大量数据持续传输的应用。Netty本质是一个NIO框架，适用于服务器通讯相关的多种应用场景要透彻理解Netty， 需要先学习NIO， 这样我们才能阅读Netty的源码。I/O。
netty-all 4.1.86 pom
05-16
Netty-all 4.1.86 pom是一个Java项目的pom文件，用于管理Netty-all这个框架的依赖。Netty是一个高性能、异步时间驱动的NIO框架，它被广泛应用于服务器端的网络编程，为开发人员提供了通讯协议的实现，如TCP、UDP、HTTP等协议。 Netty-all 4.1.86 pom文件中包含了Netty-all的所有依赖包信息，开发人员可以通过引入这个pom文件，来简化项目中对于Netty-all依赖的管理工作。在pom文件中，除了引入Netty-all本身的jar包，还包含了一些Java的基础类库，如Apache Codec、SLF4J,以及一些其他的Netty模块。 该pom文件的版本号为4.1.86，因为Netty-all是一个优秀的开源项目，其版本更新非常快，为了让开发人员更好地管理依赖包，Netty-all在pom文件中会规定版本号，以便开发人员使用合适的版本号进行开发。 总之，Netty-all 4.1.86 pom文件是Netty-all框架用来管理依赖的一个文件，也是开发人员进行Netty-all开发的一个必备文件。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yuan_404

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值