【Netty】模型篇二：通过案例分析Netty线程模型以及Netty的核心组件

置顶 已于 2022-05-03 15:13:23 修改
阅读量877 收藏 4
点赞数
分类专栏： # Netty篇 文章标签： netty java nio
于 2022-04-28 21:13:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36389060/article/details/124427870
版权

1 回顾一下上一篇文章讲的Netty执行流程

详细可以参考：【Netty】模型篇一：Netty 线程模型架构 & 工作原理 解读

Netty 线程模型详细说明

  • Netty抽象出两组 线程池：BossGroup 和 WorkerGroup
    • BossGroup 专门负责接收客户端的连接
    • WorkerGroup 专门负责网络的读写
  • BossGroup 和 WorkerGroup 类型都是 NioEventLoopGroup，NioEventLoopGroup 相当于一个 事件循环组，这个组中 含有多个事件循环 ，每一个事件循环是 NioEventLoop
  • NioEventLoop 表示一个不断循环的执行处理任务的线程， 每个NioEventLoop 都有一个selector , 用于监听绑定在其上的socket的网络通讯。
  • NioEventLoopGroup 可以有多个线程, 即可以含有多个NioEventLoop
  • 每个Boss Group 中的 NioEventLoop 循环执行的步骤：
    • 1）轮询accept 事件
    • 2）处理accept 事件，与client建立连接 , 生成 NioScocketChannel，并将其注册 Worker Group 上的某个 NIOEventLoop 上的 selector
    • 3）处理任务队列的任务，即 runAllTasks
  • 每个 Worker Group 中的 NIOEventLoop 循环执行的步骤：
    • 1）轮询 read/write 事件
    • 2）处理 I/O 事件， 即 read/write 事件，在对应的 NioScocketChannel 上处理
    • 3）处理任务队列的任务 ， 即 runAllTasks
  • 每个Worker NIOEventLoop 处理业务时，会使用 pipeline(管道)。pipline中包含了 channel，即通过pipline可以获取到对应的 channel，并且pipline维护了很多的 handler(处理器)来对我们的数据进行一系列的处理。
  • handler(处理器) 有Netty内置的，我们也可以自己定义。
    在这里插入图片描述

2 Netty 快速入门案例

下面我们通过一个案例来进一步深入理解上一节讲解的Netty线程模型的工作原理，并对其中涉及到的Netty核心组件进行详细分析

案例要求

  • Netty 服务器在 6668 端口监听，浏览器发出请求 http://localhost:6668/ ；
  • 服务器可以回复消息给客户端 "Hello! 我是服务器 5 "，并对特定请求资源进行过滤；
  • 目的：Netty 可以做Http服务开发，并且理解Handler实例和客户端及其请求的关系。

2.1 服务端代码

2.1.1 代码实现思路详解

步骤一：创建两个线程组 BossGroup 和 WorkerGroup，它们的类型都是 NioEventLoopGroup

  • BossGroup 只处理连接请求；
  • WorkerGroup处理客户端业务。
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();

步骤二：创建服务器端启动对象 ServerBootstrap ，并进行参数配置：

  • 设置 BossGroup 和 WorkerGroup；
  • 设置使用使用 NioSocketChannel 作为服务器的通道实现。
  • 设置保持活动连接；
  • 给 WorkerGroup 的 EventLoop 对应的 Pipline 设置 Handler，Handler可以是Netty内置的，也可以自己实现。
// 2.创建服务器端启动对象，配置参数
ServerBootstrap bootstrap = new ServerBootstrap();
// 使用链式编程进行设置
bootstrap.group(bossGroup,workerGroup)// 设置两个线程组
        .channel(NioServerSocketChannel.class)// 使用 NioSocketChannel 作为服务器的通道实现
        .option(ChannelOption.SO_BACKLOG,128)// 设置线程队列得到连接个数
        .childOption(ChannelOption.SO_KEEPALIVE,true)// 设置保持活动连接
        // 给 WorkerGroup 的 EventLoop 对应的 管道 设置处理器
        .childHandler(new ChannelInitializer<SocketChannel>() {
            // 向 pipline 设置 处理器
            @Override
            protected void initChannel(SocketChannel socketChannel) throws Exception {
                // 通过 channel 可以拿到 pipline，也可以通过 pipline 拿到 channel
                socketChannel.pipeline()
                        .addLast(new NettyServerHandler());// 向 pipline 添加 处理器
            }
        });

步骤三：实现Handler对象

  • 如果想自定义Handler，则需要继承Netty规定好的某个 HandlerAdapter
  • 这里先重写三个常用方法：
    • channelRead()：读取客户端的消息
    • channelReadComplete()：消息读取完毕，向客户端回复消息
    • exceptionCaught()：处理异常，一般需要关闭通道
/*
说明：
1.自定义Handler，需要继承Netty规定好的某个HandlerAdapter
2.这时我们自定义的Handler，才能称为一个Handler
 */
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    /*
    作用：读取客户端的消息
    ChannelHandlerContext ctx：上下文对象，含有 管道pipline、通道channel、地址等
    Object msg：就是客户端发送的数据 默认 Object
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("server ctx = "+ctx);
        // 将 msg 转成 ByteBuffer
        // ByteBuf 是 Netty 提供的，不是 NIO 中的
        ByteBuf buffer = (ByteBuf) msg;
        System.out.println("客户端发送的消息是："+buffer.toString(CharsetUtil.UTF_8));
        System.out.println("客户端的地址是："+ctx.channel().remoteAddress());
    }
    // 数据读取完毕，向客户端回复消息
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        // writeAndFlush 是 write + flush
        // 将数据写入到缓存，并刷新
        // 一般我们会对这个发送的数据进行编码
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端...",CharsetUtil.UTF_8));
    }
    // 处理异常，一般需要关闭通道
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }
}

步骤四：绑定端口并且同步，启动服务器，生成并返回一个 ChannelFuture 对象

ChannelFuture cf = bootstrap.bind(6668).sync();

步骤五：设置对关闭通道事件进行监听

// 对关闭通道事件进行监听
channelFuture.channel().closeFuture().sync();
2.1.2 最终代码
public class NettyServer {
    public static void main(String[] args)  {
        // 1.创建 BossGroup 和 WorkerGroup
        /*
        说明：
            1.创建两个线程组 BossGroup 和 WorkerGroup
            2.bossGroup 只处理连接请求，workerGroup 处理客户端业务
            3.两个都是无限循环
            4.BossGroup 和 WorkerGroup 还有的子线程(NioEventLoop)的个数
                默认是 cpu核数 * 2
         */
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            // 2.创建服务器端启动对象，配置参数
            ServerBootstrap bootstrap = new ServerBootstrap();
            // 使用链式编程进行设置
            bootstrap.group(bossGroup,workerGroup)// 设置两个线程组
                    .channel(NioServerSocketChannel.class)// 使用 NioSocketChannel 作为服务器的通道实现
                    .option(ChannelOption.SO_BACKLOG,128)// 设置线程队列得到连接个数
                    .childOption(ChannelOption.SO_KEEPALIVE,true)// 设置保持活动连接
                    // 给 WorkerGroup 的 EventLoop 对应的 管道 设置处理器
                    .childHandler(new ChannelInitializer<SocketChannel>() {// 创建一个通道测试对象（匿名对象）
                        // 向 pipline 设置 处理器
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            // 通过 channel 可以拿到 pipline，也可以通过 pipline 拿到 channel
                            socketChannel.pipeline()
                                    .addLast(new NettyServerHandler());// 向 pipline 添加 处理器
                        }
                    });
            System.out.println("服务器就绪...");
            // 3.绑定端口并且同步，生成一个 ChannelFuture 对象
            // 这里服务器就已经启动服务器了
            ChannelFuture cf = bootstrap.bind(6668).sync();

            // 4.对关闭通道事件进行监听
            cf.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

我们可以看到上面为 pipline 设置了一个handler对象，因此我们来实现一下 handler对象

/*
说明：
1.自定义Handler，需要继承Netty规定好的某个HandlerAdapter
2.这时我们自定义的Handler，才能称为一个Handler
 */
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    /*
    作用：读取客户端的消息
    ChannelHandlerContext ctx：上下文对象，含有 管道pipline、通道channel、地址等
    Object msg：就是客户端发送的数据 默认 Object
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("server ctx = "+ctx);
        // 将 msg 转成 ByteBuffer
        // ByteBuf 是 Netty 提供的，不是 NIO 中的
        ByteBuf buffer = (ByteBuf) msg;
        System.out.println("客户端发送的消息是："+buffer.toString(CharsetUtil.UTF_8));
        System.out.println("客户端的地址是："+ctx.channel().remoteAddress());
    }
    // 数据读取完毕，向客户端回复消息
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        // writeAndFlush 是 write + flush
        // 将数据写入到缓存，并刷新
        // 一般我们会对这个发送的数据进行编码
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端...",CharsetUtil.UTF_8));
    }
    // 处理异常，一般需要关闭通道
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }
}

2.2 客户端代码

2.2.1 代码实现思路详解

步骤一：创建一个线程组 group ，它的类型是 NioEventLoopGroup。

// 客户端需要一个事件循环组
EventLoopGroup group = new NioEventLoopGroup();

步骤二：创建客户端启动对象 Bootstrap ，并进行参数配置：

  • 设置 group；
  • 设置使用使用 NioSocketChannel 作为客户端通道的实现类；
  • 给 WorkerGroup 的 EventLoop 对应的 Pipline 设置 Handler，Handler可以是Netty内置的，也可以自己实现。
Bootstrap bootstrap = new Bootstrap();
// 设置相关参数，链式编程
bootstrap.group(group)// 设置线程组
        .channel(NioSocketChannel.class)// 设置客户端通道的实现类
        .handler(new ChannelInitializer<SocketChannel>() {
            @Override
            protected void initChannel(SocketChannel ch) throws Exception {
                ch.pipeline().addLast(new NettyClientHandler());// 加自己的处理器
            }
        });

步骤三：实现Handler对象

public class NettyClientHandler extends ChannelInboundHandlerAdapter {

    // 当通道就绪就会触发该方法
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("client ctx = "+ctx);
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello,服务端...", CharsetUtil.UTF_8));
    }
    // 当通道有读取事件时，会触发
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buffer = (ByteBuf) msg;
        System.out.println("服务器回复的消息："+buffer.toString(CharsetUtil.UTF_8));
        System.out.println("服务器的地址："+ctx.channel().remoteAddress());
    }
    // 发生异常时处理
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

步骤四：绑定 IP 和 端口 并且同步，启动客户端，生成并返回一个 ChannelFuture 对象

ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 6668).sync();

步骤五：设置对关闭通道事件进行监听

// 对关闭通道事件进行监听
channelFuture.channel().closeFuture().sync();
2.2.2 最终代码
public class NettyClient {
    public static void main(String[] args) {
        // 客户端需要一个事件循环组
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            // 创建客户端启动对象
            // 注意：客户端使用的是 Bootstrap 而不是 ServerBootStrap
            Bootstrap bootstrap = new Bootstrap();
            // 设置相关参数，链式编程
            bootstrap.group(group)// 设置线程组
                    .channel(NioSocketChannel.class)// 设置客户端通道的实现类
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new NettyClientHandler());// 加自己的处理器
                        }
                    });
            System.out.println("客户端就绪...");
            // 启动客户端连接服务端
            // 关于 ChannelFuture 涉及到 netty 的异步模式
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 6668).sync();

            // 对关闭通道事件进行监听
            channelFuture.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            group.shutdownGracefully();
        }
    } 
}

这里也需要为 pipline 设置了一个handler对象，因此我们来实现一下 handler对象

public class NettyClientHandler extends ChannelInboundHandlerAdapter {

    // 当通道就绪就会触发该方法
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("client ctx = "+ctx);
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello,服务端...", CharsetUtil.UTF_8));
    }
    // 当通道有读取事件时，会触发
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buffer = (ByteBuf) msg;
        System.out.println("服务器回复的消息："+buffer.toString(CharsetUtil.UTF_8));
        System.out.println("服务器的地址："+ctx.channel().remoteAddress());
    }
    // 发生异常时处理
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

3 代码分析

3.1 代码总结

在这里插入图片描述

由于客户端和服务端代码类似，所以我们重点分析服务端的代码。

在服务端创建了两个 线程池：BossGroup 和 WorkerGroup ，BossGroup 专门负责接收客户端的连接，WorkerGroup 专门负责网络的读写。

  • BossGroup 和 WorkerGroup 类型都是 NioEventLoopGroup，NioEventLoopGroup 相当于一个 事件循环组，这个组中 含有多个事件循环 NioEventLoop ，每一个事件循环是 NioEventLoop
  • NioEventLoop 表示一个不断循环的执行处理任务的线程， 每个NioEventLoop 都有一个selector , 用于监听绑定在其上的socket的网络通讯。

每个Boss Group 中的 NioEventLoop 循环执行的步骤：

  • 1）轮询accept 事件
  • 2）处理accept 事件，与client建立连接 , 生成 NioScocketChannel，并将其注册 Worker Group 上的某个 NIOEventLoop 上的 selector
  • 3）处理任务队列的任务，即 runAllTasks

每个 Worker Group 中的 NIOEventLoop 循环执行的步骤：

  • 1）轮询 read/write 事件
  • 2）处理 I/O 事件， 即 read/write 事件，在对应的 NioScocketChannel 上处理
  • 3）处理任务队列的任务 ， 即 runAllTasks

每个Worker NIOEventLoop 处理业务时，会使用 pipeline(管道)。pipline中包含了 channel，即通过pipline可以获取到对应的 channel，并且pipline维护了很多的 handler(处理器)来对我们的数据进行一系列的处理。handler(处理器) 可以是Netty内置的，我们也可以自己定义。

3.2 涉及到的Netty组件总结

Netty核心组件详解我们另写一篇文章分析，这里只简要说明用到了哪些组件。

  • 在创建线程组的时候用到了 NioEventLoopGroup类；
  • 在创建服务端启动对象时用到了 ServerBootstrap 类；在创建客户端启动对象时用到了 Bootstrap 类；
  • 在为启动对象配置参数时我们用到了 NioServerSocketChannel类、ChannelOption类、ChannelInitializer类；ChannelInitializer类继承了 ChannelInboundHandlerAdapter类；
  • 在自定义Handler时，我们继承了 ChannelInboundHandlerAdapter 类；在重写该类的方法中涉及到了 ChannelHandlerContext 类、ByteBuf 类、Unpooled类；
  • 在绑定端口并且同步，启动服务器，生成并返回一个 ChannelFuture类 的对象。

对于这些组件的用法，大家可以参考下一篇文章：【Netty】模型篇三：Netty核心组件讲解

熠熠98
关注
专栏目录
【Netty系列_2】Netty线程模型与核心组件解析（上）
my的博客
03-14 419
引言 说起Netty，可能很多开发者并没有使用经验，但是我敢说，在你使用的框架中，一定有他的身影，比如(RocketMQ,redisson,dubbo,motan,Elasticsearch......想了解更多使用Netty的项目? --> 戳这里 ), 在本文中，我们将以通俗易懂的方式，讲清楚每一个组件的职责和作用。 因为Netty是基于Java中NIO的封装，其本质还是使用到了Java中的NIO,所以我们先来了解下NIO的几个组件Channel ,Selector 和 ByteBuffer
40 - 案例分析（二）：高性能网络应用框架Netty
pizicai007的博客
07-19 342
案例分析（二）：高性能网络应用框架Netty1. 网络编程性能的瓶颈2. Reactor 模式3. Netty 中的线程模型4. 用 Netty 实现 Echo 程序服务端.5. 总结   Netty 是一个高性能网络应用框架，应用非常普遍，目前在 Java 领域里，Netty 基本上成为网络程序的标配了。Netty 框架功能丰富，也非常复杂，今天我们主要分析 Netty 框架中的线程模型，而线程模型直接影响着网络程序的性能。      在介绍 Netty 的线程模型之前，我们首先需要把问题搞清楚，了解网络
netty各种例子
09-14
基于netty各种例子。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
Netty入门实例-TCP服务（Netty八）
qq_36594703的博客
09-20 883
1.Netty服务器在6668端口监听，客户端能发送消息给服务器“hello 服务器”，服务器可以回复消息给客户端“hello，客户端” 服务器端代码： public class NettyServer { public static void main(String[] args) throws Exception { //创建bossGroup,workGroup //bossGroup只处理连接请求，真正的和客户的业务处理会交给workGroup完成
NIO中的异步—ChannelFuture、CloseFuture以及异步提升在NIO中的应用
最新发布
one2excellent的博客
08-19 1124
随后运行上述客户端代码，观察到日志输出如下：通过此输出日志发现借用channelFuture对象的channel方法获取的Channel对象并没有创建。原因分析：connect方法是异步的，意味着不等待连接建立，方法执行就返回了。因此channelFuture对象中不能【立刻】获取到正确的Channel对象。为什么不在一个线程中去执行建立连接、去执行关闭 channel【建立连接connet，关闭channel都是在EventLoopGroup中执行的。也即nio中执行的】，那样不是也可以吗？非要用这么
netty案例
qq_35357001的博客
08-30 638
Netty是业界最流行的NIO框架之一，它的健壮性、功能、性能、可定制性和可扩展性在同类框架中都是首屈一指的，它已经得到成百上千的商用项目验证，例如Hadoop的RPC框架avro使用Netty作为底层通信框架。很多其它业界主流的RPC框架，也使用Netty来构建高性能的异步通信能力。 通过对Netty的分析，我们将它的优点总结如下： 1)      API使用简单，开发门槛低；
netty样例
wwq_vracle的博客
05-23 183
https://github.com/menacher/nerdronix/tree/master/spring-netty/src/main
Netty 入门与实战：仿写微信 IM 即时通讯系统
06-26
总的来说，通过Netty仿写微信IM系统，我们可以深入了解网络编程、异步I/O、协议设计、以及分布式系统中的消息传递。这是一个很好的实践平台，可以帮助开发者提升对高性能网络应用开发的理解和技能。在这个过程中，你...
Netty进阶之路-跟着案例学Netty
05-16
本书首先会介绍Netty的基本概念，包括其非阻塞I/O模型、事件驱动架构以及Channel、EventLoop、Buffer等核心组件。接着，通过一系列逐步进阶的案例，如构建简单的Echo服务器、处理HTTP请求、实现WebSocket通信，读者...
netty学习（二）Netty线程模型与核心组件
lzr_ps的博客
04-22 178
netty学习（二）Netty线程模型与核心组件 1.I/O线程模型 1.1 传统阻塞IO模型 传统阻塞IO模型就是每一个请求都需要一个线程来进行处理，这个处理包括两方面： 连接的处理 业务的处理 有如下问题： 当请求过多时，创建的线程也会过多，那么线程的切换也会很频繁，上下文处理造成资源浪费 操作系统能处理的线程是有限制的，当线程达到限制后，新的请求就会被阻塞 单个线程大部分时间都是阻塞的，因为此请求并没有数据可以读写，造成了资源浪费 1.2 Reactor模型 针对传统IO模型的问题：rea
Netty 入门与实战：仿写微信 IM 即时通讯系统.zip
02-26
最后，本书可能还会涵盖安全性和性能优化方面的内容，如SSL/TLS加密、流量控制和拥塞控制，以及如何通过线程模型、内存池等手段提升系统的性能。 总之，《Netty 入门与实战：仿写微信 IM 即时通讯系统》是一本全面...
Netty应用实例
Java硬件工程师的博客
05-27 996
群聊系统 实例要求 1.编写一个 Netty 群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞） 2.实现多人群聊 3.服务器端：可以监测用户上线，离线，并实现消息转发功能 4.客户端：通过 channel 可以无阻塞发送消息给其它所有用户，同时可以接受其它用户发送的消息（有服务器转发得到） 5.目的：进一步理解 Netty 非阻塞网络编程机制 GroupChatServer import io.netty.bootstrap.ServerBootstrap; import io.netty.ch
Netty简单示例
书香水墨
07-19 1368
一、
Netty入门案例
Y_Y526的博客
01-10 420
何为Netty？ ​ Netty是一个基于NIO的客户端、服务器端的编程框架，用于快速开发可维护、高性能的网络服务器和客户端。Netty具有并发高、传输快、封装好等特点，Netty还可以通便编程自定义各种协议，可通过codec来编码或解码字节流。 入门案例 需求 完成一个简单的服务器端和客户端： 客户端向服务器端发送Hello Netty 服务器端只接收客户端发来的消息 服务端 public class NettySever { public NettySever(){ //
Netty学习笔记（三）：Netty简介、线程模型、Netty应用实例、Netty核心组件介绍
Miracle42的博客
06-11 1272
第 4 章 Netty 详解 一、Netty简介 1、NIO 存在的问题 NIO 的类库和 API 繁杂，使用麻烦：需要熟练掌握 Selector、ServerSocketChannel、SocketChannel、ByteBuffer等。 需要具备其他的额外技能：要熟悉 Java 多线程编程，因为 NIO 编程涉及到 Reactor 模式，必须对多线程 和网络编程非常熟悉，才能编写出高质量的 NIO 程序。 开发工作量和难度都非常大：例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常流
netty-demo实例
10-08
Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序dsf。 也就是说，Netty 是一个基于NIO的客户，服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户，服务端应用。Netty相当简化和流线化了网络应用的编程开发过程，例如，TCP和UDP的socket服务开发。 “快速”和“简单”并不意味着会让你的最终应用产生维护性或性能上的问题。Netty 是一个吸收了多种协议的实现经验，这些协议包括FTP,SMTP,HTTP，各种二进制，文本协议，并经过相当精心设计的项目，最终，Netty 成功的找到了一种方式，在保证易于开发的同时还保证了其应用的性能，稳定性和伸缩性。
Mysql 架构和工作流程
xinyuezitang的博客
10-31 231
一 Mysql 架构分层 总体上，我们把Mysql分为三层： 建立连接和交互的客户端 真正执行操作的服务层 跟硬件打交道的存储引擎层 二 Mysql 查询过程 （1） 查询过程 看图了解Mysql查询大致过程： 客户端向服务端发起一条请求（这里建立通信过程） 服务端先检查缓存，如果命中缓存，直接返回结果，否则进行下一阶段 服务器进行sql解析和预处理，再经过查询优化器形成对应的执行计划 mysql根据执行计划，调用API给存储引擎， 进行数据的读取和存储 缓存查询结果，并将结果返回给客户端 三 My
I/O模型与Netty（二）
u010215318的博客
04-12 188
Netty实现简易聊天室服务器端客户端 想理解一个架构的底层原理，必须先从最基础的实现开始 服务器端 public class NettyChatServer { //端口号 private int port; public NettyChatServer(int port) { this.port = port; } public void run() throws InterruptedException { //1. 创建
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

熠熠98

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

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

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

打赏作者

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

抵扣说明：

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

余额充值