Netty架构探索之NIO架构演变

最新推荐文章于 2024-04-29 22:54:22 发布
最新推荐文章于 2024-04-29 22:54:22 发布
阅读量294 收藏
点赞数
分类专栏： JAVA网络编程 个人日记 框架专题 文章标签： netty java 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/scjava/article/details/113183169
版权

Netty架构探索之NIO架构演变

Netty初探

NIO 的类库和 API 繁杂， 使用麻烦： 需要熟练掌握Selector、 ServerSocketChannel、 SocketChannel、 ByteBuffer等。 开发工作量和难度都非常大： 例如客户端面临断线重连、 网络闪断、心跳处理、半包读写、 网络拥塞和异常流的处理等等。Netty 对 JDK 自带的 NIO 的 API 进行了良好的封装，解决了上述问题。且Netty拥有高性能、 吞吐量更高，延迟更低，减少资源消耗，最小化不必要的内存复制等优点。Netty 现在都在用的是4.x，5.x版本已经废弃，Netty 4.x 需要JDK 6以上版本支持。

Netty的使用场景

1）互联网行业：在分布式系统中，各个节点之间需要远程服务调用，高性能的 RPC 框架必不可少，Netty 作为异步高性能的通信框架，往往作为基础通信组件被这些 RPC 框架使用。典型的应用有：阿里分布式服务框架 Dubbo 的 RPC 框架使用 Dubbo 协议进行节点间通信，Dubbo 协议默认使用 Netty 作为基础通信组件，用于实现。各进程节点之间的内部通信。Rocketmq底层也是用的Netty作为基础通信组件。
2）游戏行业：无论是手游服务端还是大型的网络游戏，Java 语言得到了越来越广泛的应用。Netty 作为高性能的基础通信组件，它本身提供了 TCP/UDP 和 HTTP 协议栈。
3）大数据领域：经典的 Hadoop 的高性能通信和序列化组件 Avro 的 RPC 框架，默认采用 Netty 进行跨界点通信，它的 Netty Service 基于 Netty 框架二次封装实现。
netty相关开源项目：https://netty.io/wiki/related-projects.html

Netty通讯示例

Netty的maven依赖：

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

NettyServer（Netty服务端）

package com.io.netty.demo;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class NettyServer {

    public static void main(String[] args) {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workGroup = new NioEventLoopGroup();
        try {

            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workGroup)
                    .channel(NioServerSocketChannel.class)
                    // 初始化服务器连接队列大小，服务端处理客户端连接请求是顺序处理的,所以同一时间只能处理一个客户端连接。
                    // 多个客户端同时来的时候,服务端将不能处理的客户端连接请求放在队列中等待处理
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    //创建通道初始化对象，设置初始化参数
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new NettyServerHandler());
                        }
                    });
            System.out.println("netty server start success  ");
            //绑定一个端口并且同步, 生成了一个ChannelFuture异步对象，通过isDone()等方法可以判断异步事件的执行情况
            // 启动服务器(并绑定端口)，bind是异步操作，sync方法是等待异步操作执行完毕
            ChannelFuture channelFuture = bootstrap.bind(8000).sync();
            //对通道关闭进行监听，closeFuture是异步操作，监听通道关闭
            // 通过sync方法同步等待通道关闭处理完毕，这里会阻塞等待通道关闭完成
            channelFuture.channel().closeFuture().sync();
        } catch (Exception ce) {
            ce.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }
}

NettyClient（Netty 客户端）

package com.io.netty.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) {

        EventLoopGroup clientGoup = new NioEventLoopGroup();

        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(clientGoup)
                    .channel(NioSocketChannel.class)// 使用 NioSocketChannel 作为客户端的通道实现
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new NettyClientHandler());
                        }
                    });

            //启动客户端去连接服务器端
            ChannelFuture cf = bootstrap.connect("127.0.0.1", 8000).sync();
            //对关闭通道进行监听
            cf.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            clientGoup.shutdownGracefully();
        }
    }


}

NettyClientHandler（netty客户端处理器）

package com.io.netty.demo;

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

public class NettyClientHandler extends ChannelInboundHandlerAdapter {


    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
      ctx.writeAndFlush(Unpooled.copiedBuffer("hello server", CharsetUtil.UTF_8));

    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("接受到服务端的消息："+buf.toString(CharsetUtil.UTF_8));
    }
    }

NettyServerHandler（netty服务端处理器）

package com.io.netty.demo;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

import java.nio.charset.Charset;

public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    private Charset charset;

    public NettyServerHandler() {
        charset = Charset.forName("UTF-8");
    }

    /**
     * 当客户端发送数据到通道，这里是通道读取
     *
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println(Thread.currentThread().getName() + " 接受请求");
        ByteBuf buf = (ByteBuf) msg;

        System.out.println("服务端接受到的数据:" + buf.toString(charset));
    }

    /**
     * 通道数据读取完毕调用
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        System.out.println("服务端数据读取完毕");
        ByteBuf buf = Unpooled.copiedBuffer("hello client", charset);
        ctx.writeAndFlush(buf);
    }

    /**
     * 当客户端建立了连接过后，服务端会调用channelActive方法
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("通道激活");
        //建立连接可以给客户端发送消息
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello", charset));

    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("11111");
    }

    /**
     * 当客户端建立了连接过后，要注册到通道上会调用
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
        System.out.println("注册...");
    }

    /**
     * 当客户端失去连接过后，会调用
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
        System.out.println("客户端通道移除");
    }

    /**
     * 出现异常调用
     *
     * @param ctx
     * @param cause
     * @throws Exception
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("出现异常");
    }
}

值得一说的是如果不编写客户端，只要服务端启动了，那么也是可以通过telnet 发送数据的；我们发现Netty框架的目标就是让你的业务逻辑从网络基础应用编码中分离出来，让你可以专注业务的开发，而不需写一大堆类似NIO的网络处理操作。

NIO架构演变

Netty的线程模型在《Scalable IO in Java》一书中对io的架构演变做了一个介绍，可以先理解理解下里面所说的io模型的演变，就能够更清楚的理解Netty为什么会出现

传统的BIO模型

在这里插入图片描述
传统的BIO模型在之前的笔记中已经说的很多了，BIO的模型面临的问题就是需要开启大量的线程，从上图也可以知道， 每个client请求到server过后，server都需要开启一个线程去处理client的请求，然后经过读取、解码、处理业务，最后发送请求处理结果到client，但是如果这个环节上的任何一个地方出现缓慢，那么这个线程是不会释放的，也就是会一直占用这个线程，直到send完毕，而如果大量的连接进来过后，这种模型的弊端就显而易见，要开启大量的线程，如果已经开启的线程处理不能及时完成，那么最终的结果就是后面的连接会一直阻塞在队列中而不是及时响应客户端从而线程超时。

基本的 Reactor模型

在这里插入图片描述
这种模型就是NIO的模型，这种模型采用的是linxu的epoll模型，之前的笔记中已经用了大量的文字来说明了NIO和epoll、poll、select了，这里就不多说了，这种模型采用的是事件响应机制，就是一个reactor就是一个io多路复用器Selector，所以Netty就是采用了Reactor的模型，响应式编程；这种模型在之前的笔记中已经通过对代码来说明了，就是客户端开启一个线程，客户端的这个serversocketChannel也注册到多路复用器Selector上，然后开启select（调用了linxu底层的epoll_wait)，如果在某一个时刻有客户端连接过来了或者已经有了的连接发生了事件，比如读写事件 ，那么Reactor（selector）会通知事件响应的机制接受到客户端的 socketChannel，然后进行处理，处理的事件有两种，一种acceptor（连接事件），一种数据读取事件，也就是业务处理事件；那么这种模型就是一个线程在轮询，当轮询到select的时候，如果没有事件发生，就会一直进行阻塞，如果有事件发生，那么通过selectKeys获取到发生了事件的key（socketChannel），然后进行处理，比如有 10万个连接过来了，那么selectKey中就有10万个连接请求，那么这个线程会把这10万个连接依次的注册到多路复用器selector上，之前的代码截图如下：
在这里插入图片描述
上图上之前笔记中的代码片段，这种reactor的单线程模型，可能大家想都想到了，肯定是有问题的，有什么问题呢？代码执行到1的时候，如果这个时候没有连接事件或者其他事件过来，那么会一直阻塞到1处，但是如果这个时候有10万个连接过来了，那么通过selctedKeys得到这10万个连接，并且把这个10万个连接注册到多路复用器上，但是有个问题，如果你在注册这些连接到多路复用器 上的时候，又有连接过来了，那么这个时候你还在注册之前的连接，那么这个时候其他过来的连接或者读写事件都能等着，什么事儿也做不了，再比如，如果 这10万个事件中有1万个是读事件，其他是连接，但是在2和3处都需要去处理，都需要事件，所以上面的这个写法肯定是有问题的，所以 这也就是单线程的NIO所带来的一些问题，虽然它可以将一个线程的性能压榨到极限，但是在处理的过程中也会产生一些问题，并发较高的情况下，一个线程的处理能力也是有限的，而且如果其中有些读取事件处理缓慢的话，那么和BIO一样，新过来的连接会一直处于等待状态，无法得到即使的处理响应。

多线程的Reactor模型

在这里插入图片描述
从上图可以看出在基本的模型的基础上进行了优化，acceptor是接受连接事件，而read是读取client发送数据的事件，这种优化后的模型的意思就是将上面的代码片段的3处全部 丢到一个线程池Thread Pool中去执行，意思就是读取事件交给线程池去做，而接受连接事件还是在原来的线程中去处理，因为接受连接注册到多路复用器上是很快的，分发线程处理也是很快的，处理都很快，这样在一定程度上可以解决之前的单线程模型由于事件过多而导致的后续事件的等待问题；但是这种模式还是有缺陷，有什么缺陷呢？就是比并发较高的情况下，过来的读取事件太多，连接事件也较多或者读取事件很多的情况下，分发线程还是需要一定的时间的，而且如果并发很高的情况下，线程池满了，后续的读取时间也需要阻塞的，所以在一定高并发的场景下还是有缺陷的。

主从Reactor模型

在这里插入图片描述
上面的这个模型就是典型的Netty模型，就是一主一从模型，什么意思呢？从多线程版本的Reactaor模型中可以知道，只有一个Reactor，那么不管你是否使用线程池，那么接受连接事件和抽离读取事件都是在一个Reactor中处理的，这里要明白的是一个Reactor就是一个多路复用器，现在的这种模型就是多个Reactor，也就是多个多路复用器Selector；这种多Reactor模型从上图也可以知道将处理连接事件和处理读取事件分开了，这样的好处就是主Reactor只需要处理连接时间，比如有了1000个连接过来了，主Reactor就可以直接注册到从Reactor的多路复用器上，简单来举例就是一个公司中部门经理就是比喻成一个主Reactor，他的工作就是去承接所有的项目，因为他是部门经理，人脉广，他可以一个人谈很多的项目，他谈好的项目他就可以直接转给部门员工去完成，因为项目的完成过程是很久的，所以主reactor只需要接受连接，然后注册到从Reactor的多路 复用器上，当有 读写事件过来了，直接在从reactor上进行处理，而从Reactor也是采用线程池的分发来处理的，所以这种一主一从的Reactor模型就是Netty采用的一种模型。我们来看下netty的使用的时候要创建两个线程组：

EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workGroup = new NioEventLoopGroup();

上面的bossGoup就可以看成是mainReactor，而wokGroup就是subReactor，一般mainReactor是 需要分配一个线程即可，如果你的系统并发实在是高的很，那么可以多分配几个，因为接受连接事件处理来肯定是很快的，所以一般一个线程也就够了，不需要分配太多，而如果NioEventLoopGroup构造方法没有传入具体的线程数，那么netty底层默认分配的是机器的 CPU核数 * 2；如果mainReactor分配了多个线程，那么在打开监听端口的时候就需要监听多个端口；所以这个就可以是一主一从，或者多主多从，如下图：
在这里插入图片描述

Netty的线程模型

理解了上面的NIO的线程模型的演变过后，其实Netty就是对NIO的线程模型进行了封装，成了异步非阻塞的线程模型，因为AIO目前是操作系统支持不是太好，所以在原来的NIO基础上做了一层封装，支持异步非阻塞的线程模型，而底层是基于EPOLL模型，在处理高并发的场景下是非常好的一种线程模型选择，包括阿里的dubbo底层的rpc协议也是使用netty，所以我这里从网上找了一张图来很好的说明了netty的工作架构图
在这里插入图片描述
模型解释：

  1. Netty 抽象出两组线程池BossGroup和WorkerGroup，BossGroup专门负责接收客户端的连接, WorkerGroup专门负责网络的读写
  2. BossGroup和WorkerGroup类型都是NioEventLoopGroup
  3. NioEventLoopGroup 相当于一个事件循环线程组, 这个组中含有多个事件循环线程 ， 每一个事件循环线程是NioEventLoop
  4. 每个NioEventLoop都有一个selector , 用于监听注册在其上的socketChannel的网络通讯
  5. 每个Boss NioEventLoop线程内部循环执行的步骤有 3 步
    1.处理accept事件 , 与client 建立连接 , 生成 NioSocketChannel ；
    2.将NioSocketChannel注册到某个worker NIOEventLoop上的selector；
    3.处理任务队列的任务 ， 即runAllTasks
  6. 每个worker NIOEventLoop线程循环执行的步骤
    1.轮询注册到自己selector上的所有NioSocketChannel 的read, write事件
    2.处理 I/O 事件， 即read , write 事件， 在对应NioSocketChannel 处理业务
    3.runAllTasks处理任务队列TaskQueue的任务 ，一些耗时的业务处理一般可以放入TaskQueue中慢慢处理，这样不影响数据在 pipeline 中的流动处理
  7. 每个worker NIOEventLoop处理NioSocketChannel业务时，会使用 pipeline (管道)，管道中维护了很多 handler 处理器用来处理 channel 中的数据。

Netty模块组件

【Bootstrap、ServerBootstrap】：
Bootstrap 意思是引导，一个 Netty 应用通常由一个 Bootstrap 开始，主要作用是配置整个 Netty 程序，串联各个组件，Netty 中 Bootstrap 类是客户端程序的启动引导类，ServerBootstrap 是服务端启动引导类。
【Future、ChannelFuture】：
正如前面介绍，在 Netty 中所有的 IO 操作都是异步的，不能立刻得知消息是否被正确处理。
但是可以过一会等它执行完成或者直接注册一个监听，具体的实现就是通过 Future 和 ChannelFutures，他们可以注册一个监听，当操作执行成功或失败时监听会自动触发注册的监听事件。
【Channel】：
Netty 网络通信的组件，能够用于执行网络 I/O 操作。Channel 为用户提供：
1）当前网络连接的通道的状态（例如是否打开？是否已连接？）
2）网络连接的配置参数 （例如接收缓冲区大小）
3）提供异步的网络 I/O 操作(如建立连接，读写，绑定端口)，异步调用意味着任何 I/O 调用都将立即返回，并且不保证在调用结束时所请求的 I/O 操作已完成。
4）调用立即返回一个 ChannelFuture 实例，通过注册监听器到 ChannelFuture 上，可以 I/O 操作成功、失败或取消时回调通知调用方。
5）支持关联 I/O 操作与对应的处理程序。
不同协议、不同的阻塞类型的连接都有不同的 Channel 类型与之对应。
下面是一些常用的 Channel 类型：

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

【Selector】：
Netty 基于 Selector 对象实现 I/O 多路复用，通过 Selector 一个线程可以监听多个连接的 Channel 事件。
当向一个 Selector 中注册 Channel 后，Selector 内部的机制就可以自动不断地查询(Select) 这些注册的 Channel 是否有已就绪的 I/O 事件（例如可读，可写，网络连接完成等），这样程序就可以很简单地使用一个线程高效地管理多个 Channel 。
【NioEventLoop】：
NioEventLoop 中维护了一个线程和任务队列，支持异步提交执行任务，线程启动时会调用 NioEventLoop 的 run 方法，执行 I/O 任务和非 I/O 任务：
I/O 任务，即 selectionKey 中 ready 的事件，如 accept、connect、read、write 等，由 processSelectedKeys 方法触发。
非 IO 任务，添加到 taskQueue 中的任务，如 register0、bind0 等任务，由 runAllTasks 方法触发。
【NioEventLoopGroup】：
NioEventLoopGroup，主要管理 eventLoop 的生命周期，可以理解为一个线程池，内部维护了一组线程，每个线程(NioEventLoop)负责处理多个 Channel 上的事件，而一个 Channel 只对应于一个线程。
【ChannelHandler】：
ChannelHandler 是一个接口，处理 I/O 事件或拦截 I/O 操作，并将其转发到其 ChannelPipeline(业务处理链)中的下一个处理程序。
ChannelHandler 本身并没有提供很多方法，因为这个接口有许多的方法需要实现，方便使用期间，可以继承它的子类：

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

或者使用以下适配器类：

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

【ChannelHandlerContext】：
保存 Channel 相关的所有上下文信息，同时关联一个 ChannelHandler 对象。
【ChannelPipline】：
保存 ChannelHandler 的 List，用于处理或拦截 Channel 的入站事件和出站操作。
ChannelPipeline 实现了一种高级形式的拦截过滤器模式，使用户可以完全控制事件的处理方式，以及 Channel 中各个的 ChannelHandler 如何相互交互。
在 Netty 中每个 Channel 都有且仅有一个 ChannelPipeline 与之对应，它们的组成关系如下：
在这里插入图片描述
一个 Channel 包含了一个 ChannelPipeline，而 ChannelPipeline 中又维护了一个由 ChannelHandlerContext 组成的双向链表，并且每个 ChannelHandlerContext 中又关联着一个 ChannelHandler。
read事件(入站事件)和write事件(出站事件)在一个双向链表中，入站事件会从链表 head 往后传递到最后一个入站的 handler，出站事件会从链表 tail 往前传递到最前一个出站的 handler，两种类型的 handler 互不干扰。

ByteBuf详解

从结构上来说，ByteBuf 由一串字节数组构成。数组中每个字节用来存放信息。
ByteBuf 提供了两个索引，一个用于读取数据，一个用于写入数据。这两个索引通过在字节数组中移动，来定位需要读或者写信息的位置。当从 ByteBuf 读取时，它的 readerIndex（读索引）将会根据读取的字节数递增。同样，当写 ByteBuf 时，它的 writerIndex 也会根据写入的字节数进行递增。
在这里插入图片描述
需要注意的是极限的情况是 readerIndex 刚好读到了 writerIndex 写入的地方。
如果 readerIndex 超过了 writerIndex 的时候，Netty 会抛出 IndexOutOf-BoundsException 异常。
示例代码：

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.util.CharsetUtil;

public class NettyByteBuf {
    public static void main(String[] args) {
        // 创建byteBuf对象，该对象内部包含一个字节数组byte[10]
        // 通过readerindex和writerIndex和capacity，将buffer分成三个区域
        // 已经读取的区域：[0,readerindex)
        // 可读取的区域：[readerindex,writerIndex)
        // 可写的区域: [writerIndex,capacity)
        ByteBuf byteBuf = Unpooled.buffer(10);
        System.out.println("byteBuf=" + byteBuf);

        for (int i = 0; i < 8; i++) {
            byteBuf.writeByte(i);
        }
        System.out.println("byteBuf=" + byteBuf);

        for (int i = 0; i < 5; i++) {
            System.out.println(byteBuf.getByte(i));
        }
        System.out.println("byteBuf=" + byteBuf);

        for (int i = 0; i < 5; i++) {
            System.out.println(byteBuf.readByte());
        }
        System.out.println("byteBuf=" + byteBuf);


        //用Unpooled工具类创建ByteBuf
        ByteBuf byteBuf2 = Unpooled.copiedBuffer("hello,zhuge!", CharsetUtil.UTF_8);
        //使用相关的方法
        if (byteBuf2.hasArray()) {
            byte[] content = byteBuf2.array();
            //将 content 转成字符串
            System.out.println(new String(content, CharsetUtil.UTF_8));
            System.out.println("byteBuf2=" + byteBuf2);

            System.out.println(byteBuf2.getByte(0)); // 获取数组0这个位置的字符h的ascii码，h=104

            int len = byteBuf2.readableBytes(); //可读的字节数  12
            System.out.println("len=" + len);

            //使用for取出各个字节
            for (int i = 0; i < len; i++) {
                System.out.println((char) byteBuf2.getByte(i));
            }

            //范围读取
            System.out.println(byteBuf2.getCharSequence(0, 6, CharsetUtil.UTF_8));
            System.out.println(byteBuf2.getCharSequence(6, 6, CharsetUtil.UTF_8));
        }
    }
}

Netty实战聊天室系统

ChatServer（服务端）：


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;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

public class ChatServer {


    public static void main(String[] args) {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast("encoder", new StringEncoder());
                            pipeline.addLast("decoder", new StringDecoder());
                            pipeline.addLast(new ChatServerHandler());
                        }
                    });
            ChannelFuture channel = bootstrap.bind(8000).sync();
            System.out.println("chat service staring");
            channel.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
    }
}

ChatServerHandler （服务端处理器）


import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.concurrent.GlobalEventExecutor;

import java.text.SimpleDateFormat;
import java.util.Date;

public class ChatServerHandler extends SimpleChannelInboundHandler<String> {

    private SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    static  ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

    /**
     * 发送消息读取
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        Channel channel = ctx.channel();
        channelGroup.forEach(ch ->{
            if(ch != channel){
                ch.writeAndFlush("[客户端] "+ ch.remoteAddress()  +" "+ dateFormat.format(new Date()) +" 发送了消息:" + msg +"\n");
            }else{
                ch.writeAndFlush("[自己] "+ch.remoteAddress() +" "+ dateFormat.format(new Date()) +" 发送了消息："+msg +" \n");
            }
        });

    }

    /**
     *下线了提醒
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        channelGroup.writeAndFlush("[客户端] "+channel.remoteAddress() +" 下线了 "+ dateFormat.format(new Date()) +"\n");
        System.out.println("[客户端]"+channel.remoteAddress()+"下线了 \n");
        System.out.println("下线了，size="+channelGroup.size());
    }

    /**
     * 通道激活
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        channelGroup.writeAndFlush("[客户端] "+channel.remoteAddress()+" 上线了 "+ dateFormat.format(new Date())+"\n");
        channelGroup.add(channel);
        System.out.println(channelGroup.size());
        System.out.println("[客户端] "+channel.remoteAddress()+" 上线了 \n");
    }

}

ChatClient （客户端）：


import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

import java.util.Scanner;

public class ChatClient {

    public static void main(String[] args) {
        EventLoopGroup workGroup = new NioEventLoopGroup();

        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(workGroup)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast(new StringEncoder());
                            pipeline.addLast(new StringDecoder());
                            pipeline.addLast(new ChatClientHandler());
                        }
                    });
            ChannelFuture future = bootstrap.connect("127.0.0.1", 8000).sync();

            Channel channel = future.channel();
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNext()){
                String s = scanner.nextLine();
                channel.writeAndFlush(s);
            }
            channel.closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            workGroup.shutdownGracefully();
        }
    }
}

ChatClientHandler （客户端处理器）


import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class ChatClientHandler extends SimpleChannelInboundHandler<String> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println(msg);
    }
}

我在码云上之前写了一个netty的简单rpc通讯框架，就是学习使用的
https://gitee.com/scjava/bml-rpc.git

Life journey
关注
专栏目录
NIO模型实现
weixin_44916741的博客
02-17 313
单线程NIO 如果要实现NIO的网络模型，我们就需要三大组件：Selector，Channel，ByteBuffer Selector : 用来监听Channel上的某种事件 Channel：一个服务器对应一个Channel，也就是一个管道。 ByteBuffer：指的是字节缓冲区，我们要把数据流读取到ByteBuffer中才能获取并处理它，或者把数据写入ByteBuffer中，才可以将它发送到网...
【分布式架构设计&微服务深入剖析01】之分布式理论、架构设计（自定义RPC）
yuyangzhi10的博客
12-06 2625
1、分布式理论 1.1 分布式架构系统回顾 1.1.1 分布式系统概念 分布式系统 分布式系统是一个硬件或软件组件分布在不同的网络计算机上，彼此之间仅仅通过消息传递进行通信和协调的系统 通俗的理解，所谓分布式系统，就是一个业务拆分成多个子业务，分布在不同的服务器节点，共同构成的系统称为分布式系统 同一个分布式系统中的服务器节点在空间部署上是可以随意分布的 这些服务器可能放在不同的机柜中，也可能在不同的机房中，甚至分布在不同的城市 分布式与集群的区别 集群：多个人在一起作同样的事 分布式 ：多个人在一起
NIO（non-Blocking）的简单原生实现
qq_35480753的博客
12-02 268
最近在学习过程中，稍微比较了下Tomcat与Netty的区别。 Tomcat主要为http协议的web容器，不适合自定义协议等一定操作。 Netty的话，则一定要提到他的高并发的网络编程接口框架。使用NIO的方式进行通信，NIO，同步非阻塞式通信，它相较于传统IO来说，他仅需要一个线程用来管理建立连接的事情，尽管建立玩连接后的IO仍然是同步等待的，但是已经有了很大的并发支持性。（Netty官网的介绍也有提到他的NIO方式） 于是，我动手写了一个简单的基于NIO底层的服务端-客户端实例，也贴了详细注释，欢迎讨
NIO(Non-blocking I/O)
weixin_46591816的博客
03-11 348
NIO（Non-blocking I/O，在Java领域，也称为New I/O），是一种同步非阻塞的I/O模型，也是I/O多路复用的基础，已经被越来越多地应用到大型应用服务器，成为解决高并发与大量连接、I/O处理问题的有效方式。
【Java NIO】之 NonBlockingNIO
王廷云的博客
07-05 217
下面以一个实例介绍 NonBlockingNIO 的用法 /** * 一、使用 NIO 完成网络通信的三个核心： * * 1. 通道（Channel）：负责连接 * * java.nio.channels.Channel 接口： * |--SelectableChannel * |--SocketChannel * |--ServerSocketChannel * |--DatagramChannel * * |--Pipe.SinkC.
网络IO之NIO的演变过程
热门推荐
morris
11-05 2万+
NIO演变过程 本文会使用strace命令一步一步跟踪程序底层所产生的系统调用来分析NIO的演变过程。 NIO的阻塞模式 package com.morris.nio; import java.io.IOException; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.ServerSocketChannel; import java.nio.channels.SocketCh
Netty 5.0架构详解与源码深度解析
Netty架构部分，作者阐述了其逻辑架构，即事件驱动的模型，如何通过事件循环和事件处理器来管理大量的并发连接，实现实时高效的网络通信。这种架构允许Netty在不阻塞主线程的情况下处理多个请求，极大地提高了系统的...
Netty 5.0架构解析与源码深度解读
Netty5.0架构剖析和源码解读深入探讨了Java IO模型的发展与演变，特别是针对传统BIO通信方式的局限性。BIO（Blocking I/O）模型在早期的Java中被广泛应用，其主要特点是单线程处理I/O请求，导致在高并发场景下性能...
Netty 5.0架构详解：从演进到源码解析
4. **Netty架构**： - 本书还涵盖了Netty的逻辑架构，即事件驱动的模型，它利用事件循环器（Event Loop）和事件管道（Event Channel）机制，实现了高效的事件处理和通道复用。 5. **附录**： - 提供了作者的简介...
NIO（非阻塞 I/O）和 IO（阻塞 I/O）详解
最新发布
Reggie97的博客
04-29 2499
本文详细介绍了阻塞IO和非阻塞NIO，分析NIO中的Channel、Buffer和Selector等内容，附带示例介绍，同时利用代码对比了阻塞IO和非阻塞NIO
NIO10——Non-blocking Server
如不來的博客
11-25 239
 即使你了解 Java NIO 的非阻塞功能是怎么工作的，设计一个非阻塞的 Java NIO server 依然很困难。和阻塞式的 IO 相比，非阻塞的 IO 有多个挑战。下面就讨论一下非阻塞的 Server 面临的主要挑战，并提供一些可能的解决方案。  虽然这里描述的方案是围绕着 Java NIO 的，我想这些方案也同样适用于那些类似于 Selector 的结构的场景。这些数据结构是由底层操作系...
NIO之路1--传统BIO到NIO的演变过程
Lee_0202的博客
06-12 329
一、BIO时代 BIO1.0版本 在jdk1.4之前，java网络编程都是采用的BIO模式，BIO全称是Blocking IO，也就是阻塞式IO 接下来就以拨打10086客服电话为例，介绍下BIO是如何通信的。（10086客服是服务端，移动用户是客户端，10086是端口号） BIO1.0版本 客服等待用户拨打电话10086，此时是阻塞的，因为客服不能干别的事，只能等待客户拨打电话。当...
NIO 原理&实现
JimmyYang的博客
04-18 579
待续··· ···
nio思想和netty架构学习
weixin_40809627的博客
04-20 277
1、传统的IO 进行读写数据 使用传统的I/O程序读取文件内容，并写入到另外一个文件（或Socket），如下程序： file.read(fileDesc, buf, len); Socket.send(socket,buf，len) 会有很大的内存开销。主要分为一下两方面 1）、上下文切换（context switch），此处有4次用户态和内核态的切换。 2）、buffer内存开销方面，一个是应用...
这可能是目前最透彻的Netty原理架构解析二
Netty_cgmx9880的博客
04-02 288
Netty 工作原理架构 初始化并启动 Netty 服务端过程如下： public static void main(String[] args) { // 创建mainReactor NioEventLoopGroup boosGroup = new NioEventLoopGroup(); // 创建工作线程组 NioEventLoopGroup workerGroup = new NioEventLoopGroup(); final Serv
16.安心技术梳理 - Netty和Reactor模式和NIO
majunzhu的博客
09-15 214
Dubbo和Tomcat底层用Netty实现，Netty基于Reactor模式原理完成，Reactor底层实现是NIO方式 Redis基于Reactor模式 NIO为实现Reactor模式提供了基础，上面的NIO图示其实就是Reactor模式的雏形，只是Reactor以OO的方式抽象出了几个概念，使得职责划分更加明确。 Reactor：Reactor是IO事件的派发者，对应NIO的Selec...
NIO基于通道的网络IO，服务端获得客户端数据
wawalker的博客
02-27 276
@Test public void serverdemo() throws IOException { ServerSocketChannel channel = ServerSocketChannel.open(); channel.socket().bind(new InetSocketAddress(8888)); SocketChannel c = null; while(c == null){ c = channel.accept();//服务端.
Netty学习——整体架构
hxyascx的博客
02-25 574
Netty 整体结构 Netty 是一个设计非常用心的网络基础组件，Netty 官网给出了有关 Netty 的整体功能模块结构，却没有其他更多的解释。从图中，我们可以清晰地看出 Netty 结构一共分为三个模块： Core 核心层 Core 核心层是 Netty 最精华的内容，它提供了底层网络通信的通用抽象和实现，包括可扩展的事件模型、通用的通信 API、支持零拷贝的 ByteBuf 等。 Protocol Support 协议支持层 协议支持层基本上覆盖了主流协议的编解码实现，如 HTTP、SSL、Pr
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值