Netty深入学习（二）

最新推荐文章于 2023-07-03 18:42:48 发布

yongmingyongye

最新推荐文章于 2023-07-03 18:42:48 发布

阅读量180

点赞数

分类专栏：个人学习 Netty 文章标签： netty java

本文链接：https://blog.csdn.net/yongmingyongye/article/details/116167574

版权

个人学习同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

Netty

2 篇文章 0 订阅

订阅专栏

1、Netty

1.1 原生NIO存在的问题

1）NIO的类库和API繁杂，使用麻烦；需要熟练掌握Selector、ServerSocketChannel、SocketChannel、ByteBuffer等。

2）需求具备其他的额外技能：要熟悉Java多线程编程，因为NIO编程涉及到Reactor模式，你必须对多线程和网络编程非常熟悉，才能编写出高质量的NIO程序。

3）开发工作量和难度非常大：如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常流的处理

4）JDK NIO的Bug：如Epoll Bug，它会导致Selector空轮询，最终导致CPU100%。

1.2 Netty说明

1）Netty是由JBOSS提供的一个Java开源框架。Netty提供异步的、基于事件驱动的网络应用程序框架，用以快速开发高性能、高可靠性的网络IO程序

2）Netty可以帮助你快速、简单的开发出一个网络应用、相当于简化和流程化了NIO的开发过程

3）Netty是目前最流行的NIO框架，Netty在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，知名的Elasticsearch、Dubbo等内部都采用了Netty。

1.3 Netty的优点

1）设计优雅：适用于各种传输类型的统一API阻塞和非阻塞Socket；基于灵活且可扩展的事件模型，可以清晰地分离关注点；高度可定制的线程模型 ——单线程，一个或多个线程池

2）使用方便：没有其他依赖项，JDK就足够了

3）高性能、吞吐量更高；延迟更低；减少资源消耗；最小化不必要的内存复制

4）安全：完整的SSL/TLS和StartTLS支持

5）社区活跃、不断更新

1.4 线程模型概述

1）不同线程模式，对程序的性能有很大影响

2）目前存在的线程模型有：

传统阻塞I/O服务模型、Reactor模式

3）根据Reactor的数量和处理资源池线程数量不同，有3中典型的实现

单Reactor单线程
单Reactor多线程
主从Reactor多线程

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

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

工作原理图：

黄色框代表对象，蓝色框表示线程，白色框表示方法（API）

模型特点：

采用阻塞IO模型获取输入的数据
每个连接都需要独立的线程完成数据的输入，业务处理，数据返回

问题分析：

当并发数很大，就会创建大量的线程，占用很大系统资源
连接创建后，如果当前线程暂时没有数据可读，该线程会阻塞在read，造成线程资源浪费

1.4.2 Reactor模式

针对传统I/O模型的两个缺点，解决方案：

1）基于I/O复用模型：多个连接共用一个阻塞对象，应用程序只需要在一个阻塞对象等待，无需阻塞等待所有连接。当某个连接有新的数据可以处理时，操作系统通知应用程序，线程从阻塞状态返回，开始进行业务处理

2）基于线程池复用线程资源：不必再为每个连接创建线程，将连接完成后的业务处理任务分配给线程进行处理，一个线程可以处理多个连接的业务。

I/O复用结合线程池就是Reactor模式的基本设计思想，如下图

说明

Reactor模式，通过一个或多个输入同时传递给ServiceHandler（基于事件驱动）
服务器端程序处理传入的多个请求，并将它们同步分派到响应的处理线程，因此Reactor模式也叫Dispatcher模式
Reactor模式使用IO复用监听事件，收到事件后分发给某个线程（进程），这就是网络服务高并发处理的关键

Reactor模式中核心组成：

1）Reactor：Reactor在一个单独的线程中运行，负责监听和分发事件，分发给适当的处理程序来对IO事件作出反应。

2）Handlers：处理程序执行I/O事件要完成的实际事件，类似于客户想要与之交谈的公司的实际员工。Reactor通过调度适当的处理程序来响应I/O事件，处理程序执行非阻塞操作

1.4.3 Reactor模式分类

（1）单Reactor单线程

工作原理示意图

说明：

1）Select是前面I/O复用模型介绍的标准网络编程API，可以实现应用程序通过一个阻塞对象监听多路连接请求

2）Reactor对象通过Select监控客户端请求事件，收到事件后通过Dispatch进行分发

3）如果是建立连接请求事件，则由Acceptor通过Accept处理连接请求，然后创建一个Handler对象处理连接完成后的后续业务处理

4）如果不是建立连接事件，则Reactor会分发调用连接对应的Handler来响应

5）Handler会完成Read->业务处理->Send的完成业务流程

方案优点：

模型简单，没有多线程、进程通信、竞争的问题，全部都在一个线程中完成

方案缺点：

1）性能问题，只有一个线程，无法完成发挥多核CPU的性能。Handler在处理某个连接上业务时，整个进程无法处理其他连接事件，很容易导致性能瓶颈

2）可靠性问题，线程意外终止，或者进入死循环，会导致整个系统通信模块不可用，不能接受和处理外部信息，造成节点故障

使用场景：客户端的数量有限，业务处理非常快速，比如Redis在业务处理的时间复杂度O(1)的情况。

（2）单Reactor多线程

工作原理图：

方案说明：

1）Reactor对象通过select监控客户端请求事件，收到事件后，通过dispatch进行分发

2）如果建立连接请求，则Acceptor通过accept处理连接请求，然后创建一个Handler对象处理完成连接后的各种事件

3）如果不是连接请求，则由reactor分发调用连接对应的handler来处理

4）handler只负责响应事件，不做具体的业务处理，通过read读取数据后，会分发给后面的worker线程池的某个线程处理业务

5）worker线程池会分配独立线程完成真正的业务，并将结果返回给handler

6）handler收到响应后，通过send将结果返回给client

方案优缺点分析：

优点：

可以充分利用多核CPU的处理能力

缺点：

多线程数据共享和访问比较复杂，reactor处理所有的事件的监听和相应，且是在单线程运行，在高并发场景容易出现性能瓶颈

（3）主从Reactor多线程

工作原理示意图：

方案说明：

1）Reactor主线程MainReactor对象通过select监听连接事件，收到事件后，通过Acceptor处理连接事件

2）当Acceptor处理连接事件后，MainReactor将连接分配给SubReactor

3）subreactor将连接加入到连接队列进行监听，并创建handler进行各种事件处理

4）当有新事件发生时，subreactor就会调用对应的handler处理

5）handler通过read读取数据，分发给后面的worker线程处理

6）worker线程池分配独立的worker线程进行业务处理，并返回结果

7）handler收到响应的结果后，再通过send将结果返回给client

8）Reactor主线程可以对应多个Reactor子线程，即MainReactor可以关联多个SubReactor

方案优缺点说明：

优点：

1）父线程与子线程的数据交互简单职责明确，父线程只需要接收新连接，子线程完成后续的业务处理

2）父线程与子线程的数据交互简单，Reactor主线程主需要把新连接传给子线程，子线程无需返回数据

缺点：

编程复杂度较高

实例：这种模型在很多项目中广泛使用，包括Nginx主从Reactor多进程模型，Memcached主从多线程，Netty主从多线程模型的支持

Reactor模式具有如下的优点：

响应快，不必为单个同步时间所阻塞，虽然Reactor本身依然是同步的
可以最大程度的避免复杂的多线程及同步问题，并且避免了多线程/进程的切换开销
扩展型号，可以方便的通过增加Reactor实例个数来充分利用CPU资源
复用性好，Reactor模型本身与具体事件处理逻辑无关，具有很高的复用性

1.5 Netty模型

工作原理示意图——简单版

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

BossGroup线程维护Selector，只关注Accept
当接收到Accept事件，获取到对应的SocketChannel，分装成NIOSocketChannel并注册到Worker线程（事件循环），并进行维护
当Worker线程监听到selector中通道发生自己感兴趣的事件（读写事件）后，就进行处理（就是handler），注意handler已经加入到通道

工作原理示意图——进阶版

工作原理图——详细版

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

2）BossGroup和WorkerGroup类型都是NIOEventLoopGroup

3）NIOEventLoopGroup相当于一个事件循环组，这个组中含有多个事件循环，每一个事件循环是NIOEventLoop

4）NIOEventLoop表示一个不断循环执行处理任务的线程，每个NIOEventLoop都有一个selector，用于监听绑定在其上的socket的网络通讯

5）NIOEventLoop可以有多个线程，即可以含有多个NIOEventLoop

6）每个Boss NIOEventLoop执行的步骤分3步：

轮询accept事件
处理accept事件，与client建立连接，生成NIOSocketChannel，并将其注册到某个worker NIOEventLoop上的selector
处理任务队列的任务，即runAllTasks

7）每个Worker NIOEventLoop循环执行的步骤

轮询read、write事件
处理I/O事件，即read、write事件，在对应NIOSocketChannel处理
处理任务队列的任务，即runAllTasks

8）每个Worker NIOEventLoop处理业务时，会使用pipeline（管道），pipeline中包含了channel，即通过pipeline可以获取到对应的通道，管道中维护了很多的处理器

1.6 Netty快速入门

要求：创建一个Netty项目，Netty服务器在7777端口监听，客户单发送消息给服务器，服务器可以回复消息给客户端。

TCP服务

服务端：

public class NettyServer {
    public static void main(String[] args) throws InterruptedException {
        // 创建BossGroup 和 WorkerGroup
        // 说明
        // 1、创建了两个线程组
        // 2、bossGroup 只处理连接请求，真正和客户端业务处理交给workerGroup完成
        // 3、两个线程组都是循环的
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            // 创建服务器的启动对象，配置参数
            ServerBootstrap bootstrap = new ServerBootstrap();
            // 使用链式编程来进行设置
            bootstrap.group(bossGroup, workerGroup) // 设置两个线程组
                .channel(NioServerSocketChannel.class) // 使用 NioSocketChannel 作为服务器的通道实现
                .option(ChannelOption.SO_BACKLOG, 128) // 设置线程队列，等待连接的个数
                .childOption(ChannelOption.SO_KEEPALIVE, true) // 设置保持活动连接状态
                .childHandler(new ChannelInitializer<SocketChannel>() { // 创建一个通道测试对象（匿名内部类）
                    // 给pipeline 设置处理器
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new NettyServerHandler()); // 向pipeline（管道）的最后添加
                    }
                }) ;// 给WorkerGroup 的 EventLoop 对应的管道设置处理器

            System.out.println("-------Server is ready---------");
            // 绑定一个端口并且同步，生成一个 ChannelFuture 对象
            // 启动服务器
            ChannelFuture cf = bootstrap.bind(7777).sync();

            // 对关闭通道进行监听
            cf.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
        }
    }
}

/**
 * 自定义一个Handler 需要继承netty规定好的某个HandlerAdapter
 */
public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    /**
     * 实际读取数据操作（这里可以读取客户端发送的消息）
     * @param ctx 上下文对象，含有 pipeline、channel、地址
     * @param msg 客户端发送的数据，默认为Object
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("server ctx = " + ctx);
        // 将msg转成一个ByteBuf
        // ByteBuf 与 NIO的ByteBuffer不是一个
        ByteBuf buf = (ByteBuf) msg;
        System.out.println("客户端发送消息是：" + buf.toString(CharsetUtil.UTF_8));
        System.out.println("客户端地址：" + ctx.channel().remoteAddress());
    }

    /**
     * 数据读取完毕
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        // write + flush
        // 将数据写入到缓存，并刷新
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello，客户端...", CharsetUtil.UTF_8));
    }

    // 处理异常，一般是需要关闭通道
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }
}

客户端：

public class NettyClient {
    public static void main(String[] args) throws InterruptedException {
        // 客户端需要一个事件循环组
        EventLoopGroup eventExecutors = new NioEventLoopGroup();
        // 创建客户端启动对象
        // 注意客户端使用的不是 ServerBootStrap 而是 BootStrap
        Bootstrap bootstrap = new Bootstrap();
        try {
            // 设置相关参数
            bootstrap.group(eventExecutors) // 设置线程组
                    .channel(NioSocketChannel.class) // 设置客户端通道实现
                    .handler(new ChannelInitializer<SocketChannel>() {
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(null); // 加入自己的处理器
                        }
                    });
            System.out.println("客户端 is OK...");
            // 启动客户端去连接服务器端
            // channelFuture涉及到netty的异步模型
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 7777).sync();
            // 给关闭通道进行监听
            channelFuture.channel().closeFuture().sync();
        } finally {
            eventExecutors.shutdownGracefully();
        }
    }
}

public class NettyClientHandler extends ChannelInboundHandlerAdapter {
    // 当通道就绪就会触发该方法
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("client " + ctx);
        ctx.writeAndFlush(Unpooled.copiedBuffer("hello，服务端...", 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));
        System.out.println("服务器的地址：" + ctx.channel().remoteAddress());
    }

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

程序分析：（Debug运行查看）

1）bossGroup、workerGroup含有的子线程（NIOEventLoop）的个数，默认为电脑实际cpu核数 * 2，可通过源码查询得知，查看NioEventLoopGroup的源码，可以找到MultithreadEventLoopGroup类，分析该类代码如下：

private static final int DEFAULT_EVENT_LOOP_THREADS;
static {
    DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
            "io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2)); // NettyRuntime.availableProcessors() 返回当前计算机CPU的核数

    if (logger.isDebugEnabled()) {
        logger.debug("-Dio.netty.eventLoopThreads: {}", DEFAULT_EVENT_LOOP_THREADS);
    }
}
...
protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
    super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
}

2）workerGroup的NIOEventLoop默认按轮询负载均衡的方式

3）每一个NIOEventLoop都有一个selector

4）pipeline本质是一个双向链表，channel与pipeline是相关关联的

1.7 任务队列

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

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

2）用户自定义定时任务

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

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

通过代码模拟耗时业务执行（修改NettyServerHandler类）：

public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception 
        // 模拟一个非常耗时的业务
        // 异步执行 -> 提交该Channel对应的NioEventLoop的taskQueue中
        Thread.sleep(10 * 1000); // 休眠10秒
        ctx.writeAndFlush(Unpooled.copiedBuffer("模拟延时很长的业务", CharsetUtil.UTF_8));
        System.out.println("go on ...");
    }

这时，客户端与服务端通信时，必须要等待10秒后才能接收到从服务端发送的消息，数据被阻塞了。

解决方案一：普通任务

    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

        // 解决方案1 用户程序自定义的普通任务
        ctx.channel().eventLoop().execute(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(10 * 1000); // 休眠10秒
                    ctx.writeAndFlush(Unpooled.copiedBuffer("模拟耗时很长的业务", CharsetUtil.UTF_8));
                } catch (Exception e) {
                    System.out.println("发生异常：" + e.getMessage());
                }
            }
        });
        System.out.println("go on ...");
    }

普通任务是将任务添加到eventLoop的taskQueue中

解决方案二：自定义定时任务

    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

        // 用户自定义定时任务 -> 该任务提交到scheduleTaskQueue中
        ctx.channel().eventLoop().schedule(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(10 * 1000); // 休眠10秒
                    ctx.writeAndFlush(Unpooled.copiedBuffer("模拟耗时很长的业务，用户自定义定时任务", CharsetUtil.UTF_8));
                } catch (Exception e) {
                    System.out.println("发生异常：" + e.getMessage());
                }
            }
        }, 5, TimeUnit.SECONDS);

        System.out.println("go on ...");
    }

自定义定时任务是将任务添加到eventLoop的scheduleTaskQueue中

解决方案三：非当前Reactor线程调用Channel

通过集合将其管理起来，再通过id去查找，找到channel对应的eventLoop，最后将其任务提交过去。

1.8 异步模型

（1）基本介绍：

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

（2）Future

Future是什么？

表示异步的执行结果，可以通过它提供的方法来检查执行是否完成，比如检索计算等。

ChannelFuture是一个接口：public interface ChannelFuture extends Future<Void>；我们可以添加监听器，当监听的事件发生时就会通知到监听器，案例说明

工作原理图：

简单图形：

说明：

在使用Net图进行编程时，拦截操作和转换出入站数据只需要提供callback或利用future即可。这使得链式操作简单、高效，并有利于编写可重用的、通用代码
Netty框架的目标就是让你的业务逻辑从网络基础应用编码中分离出来、解脱出来

Future-Listener机制：

当Future对象刚刚创建时，处于非完成状态，调用者可以通过返回的ChannelFuture来获取操作执行的状态，注册监听函数来执行完成后的操作。
常见有如下操作：

通过isDone方法来判断当前操作是否完成
通过isSuccess方法来判断已完成的当前操作是否成功
通过getCause方法来获取已完成的当前操作失败的原因
通过isCancelled方法来判断已完成的当前操作是否被取消
通过addListener方法来注册监听器，当操作已完成（isDone方法返回完成），将会通知指定的监听器；如果Future对象已完成，则通知指定的监听器

举例说明：

serverBootstrap.bind(port).addListener(future -> {
    if (future.isSuccess()) {
        System.out.println("端口：[" + port + "] 绑定成功")
    } else {
        System.out.println("端口：[" + port + "] 绑定失败")
    }
});

（3）快速入门实例——Http服务

要求：

Netty服务器在7777端口监听，浏览器发出请求"http://localhost:7777"
服务器可以回复消息给客户端“我是服务器”，并对特定请求资源进行过滤

目的：Netty可以做Http服务开发，并且理解Handler实例和客户端及其请求的关系。

实现Netty服务器：

public class HttpServer {

    private static final int PORT = 7777;

    public static void main(String[] args) throws Exception {
        // 初始化为1个EventLoop
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ServerInitializer());
            ChannelFuture channelFuture = serverBootstrap.bind(PORT).sync();
            channelFuture.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

自定义一个ChannelInitializer：

public class ServerInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        // 向管道加入处理器
        // 得到管道
        ChannelPipeline pipeline = ch.pipeline();
        // 加入netty提供的httpServerCodec （codec -> coder - decoder ）
        // 1、HttpServerCodec是netty提供的处理http的编码解码器
        pipeline.addLast("MyHttpServerCodec", new HttpServerCodec());
        // 2、增加一个自定义的handler
        pipeline.addLast("", new HttpServerHandler());

    }
}

自定义一个handler：

/**
 * 说明：
 * 1、SimpleChannelInboundHandler 是 ChannelInboundHandlerAdapter
 * 2、HTTPObject 客户端和服务器端相互通讯的数据被封装成HTTPObject
 */
public class HttpServerHandler extends SimpleChannelInboundHandler<HttpObject> {
    //
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {
        // 判断msg是不是httprequest请求
        if (msg instanceof HttpRequest) {

            // 对比每次访问的pipeline与handler进行查看，每个浏览器访问都有独立的pipeline和handler
            System.out.println("pipeline hashcode：" + ctx.pipeline().hashCode() + "\tHttpServerHandler hash：" + this.hashCode());

            
            System.out.println("msg 类型 = " + msg.getClass());
            System.out.println("客户端地址" + ctx.channel().remoteAddress());
            // 回复信息给浏览器 [http协议]
            ByteBuf content = Unpooled.copiedBuffer("hello，我是服务器", CharsetUtil.UTF_8);
            // 构造一个http的相应，即httpresponse
            FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, content);
            response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain");
            response.headers().set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());
            // 将构建好 response返回
            ctx.writeAndFlush(response);
        }
    }
}

问题：通过浏览器访问一次，但控制台输出却有两次。

原因：通过浏览器的开发者工具分析可知，在请求连接时还发起了一个“favicon.ico”的请求

1.9 Netty核心模块

1.9.1 Bootstrap、ServerBootstrap

（1）Bootstrap意思为引导，一个Netty应用通常由一个Bootstrap开始，主要作用是配置整个netty程序，串联各个组件，Netty中Bootstrap类是客户单程序的启动引导类，ServerBootstrap是服务端启动引导类

（2）常见方法

public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup)，该方法用于服务器端，用来蛇者两个EventLoop
public B group(EventLoopGroup group)，该方法用于客户端，用来设置一个EventLoop
public B channel(Class<? extends C> channelClass)，该方法用来设置一个服务端的通道实现
public <T> B option(ChannelOption<T> option, T value)，用来给ServerChannel添加配置
public <T> ServerBootstrap childOption(ChannelOption<T> childOption, T value)，用来给接收到的通道添加配置
public ServerBootstrap childHandler(ChannelHandler childHandler)，该方法用来设置业务处理类（自定义的handler）// 注：该类中还有一个handler方法，这两个方法的区别是：handler对应bossGroup、childHandler对应workerGroup
public ChannelFuture bind(int inetPort)，该方法用于服务端，用来设置占用的端口号
public ChannelFuture connect(String inetHost, int inetPort)，该方法用于客户端，用来连接服务器

1.9.2 Future、ChannelFuture

（1）Netty中所有的IO操作都是异步的，不能立刻得知消息是否被正确处理。但是可以过一会等它执行完成或直接注册一个监听，具体的实现就是通过Future和ChannelFuture，它们可以注册一个监听当操作执行成功或失败时监听会自动触发注册的监听事件

（2）常见方法

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

1.9.3 Channel

（1）Netty网络通信的组件，能够用于执行网络I/O操作。

（2）通过Channel可获得当前网络连接的通道的状态

（3）通过Channel可获得网络连接的配置参数（例如接收缓冲区大小）

（4）Channel提供异步的网络I/O操作（如建立连接、读写、绑定端口），异步调用意味着任何I/O调用都将立即返回，并且不保证在调用结束时所请求的I/O操作已完成

（5）调用立即返回一个ChannelFuture实例，通过注册监听器到ChannelFuture上，可以I/O操作成功、失败或取消时回调通知调用方

（6）支持关联I/O操作与对应的处理程序

（7）不同协议、不同的阻塞类型的连接都有不同的Channel类型与之对应，常用的Channel类型：

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

1.9.4 Selector

（1）Netty基于Selector对象实现I/O多路复用，通过Selector一个线程可以监听多个连接的Channel事件

（2）当向一个Selector中注册Channel后，Selector内部的机制就可以自动不断地查询（Select）这些注册的Channel是否有已就绪的I/O事件（例如可读、可写、网络连接完成等），这样程序就可以很简单的使用一个线程高效的管理多个Channel

1.9.5 ChannelHandler及其实现类

（1）ChannelHandler是一个接口，处理I/O事件或拦截I/O操作，并将其转发到其ChannelPipeline（业务处理链）中的下一个处理程序

（2）ChannelHandler本身并没有提供很多方法，因为这个接口有很多的方法需要实现，方便使用期间，可以继承它的子类

（3）ChannelHandler及其实现类一览图

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

// 适配器

ChannelInboundHandlerAdapter用于处理入站I/O事件。
ChannelOutboundHandlerAdapter用于处理出站I/O事件。
ChannelDuplexHandler用于处理入站和出站事件

（4）我们经常需要自定义一个Handler类去继承ChannelInboundHandlerAdapter，然后通过重写相应方法实现业务逻辑，接下来看看一般都需要重写哪些方法

1.9.6 Pipeline和ChannelPipeline

ChannelPipeline是一个重点：

（1）ChannelPipeline是一个Handler的集合，它负责处理和拦击inbound或者outbound的事件和操作，相当于一个贯穿Netty的链。（也可以理解为：ChannelPipeline是保存ChannelHandler的List，用于处理或拦截Channel的入站事件和出站操作）

（2）ChannelPipeline实现了一种高级形式的拦截过滤器模式，使用户可以完全控制事件的处理方式，以及Channel中各个的ChannelHandler如何相互交互

（3）在Netty中每个Channel都有且仅有一个ChannelPipeline与之对应，它们的组成关系如下：

一个Channel包含了一个ChannelPipeline，而ChannelPipeline中又维护了一个由ChannelHandlerContext组成的双向链表，并且每个ChannelHandlerContext中关联着一个ChannelHandler
入站事件和出站操作在一个双向链表中，入站事件会从链表head往后传递到最后一个入站的handler，出站事件会从链表tail往前传递到最前一个出站的handler，两种类型的handler互不干扰。

（4）常用方法

ChannelPipeline addFirst(ChannelHandler... handlers)，把一个业务处理类（handler）添加到链中的第一个位置
ChannelPipeline addLast(ChannelHandler... handlers)，把一个业务处理类（handler）添加到链中的最后一个位置

1.9.7 ChannelHandlerContext

（1）保存Channel相关的所有上下文信息，同时关联一个ChannelHandler对象

（2）即ChannelHandlerContext中包含一个具体的事件处理器ChannelHandler，同时ChannelHandlerContext中也绑定了对应的pipeline和Channel的信息，方便对ChannelHandler进行调用

（3）常用方法

ChannelFuture close()，关闭通道

ChannelOutboundInvoker flush()，刷新

ChannelFuture writeAndFlush(Object msg)，将数据写到ChannelPipeline中当前ChannelHandler 的下一个ChannelHandler开始处理（出站）

1.9.10 ChannelOption

（1）Netty在创建Channel实例后一般都需要设置ChannelOption参数。

（2）ChannelOption参数如下：

ChannelOption.SO_BACKLOG

对应TCP/IP协议listen函数中的backlog参数，用来初始化服务器可连接队列大小。服务器处理客户端连接请求是顺序处理的，所以同一时间只能处理一个客户端连接。多个客户端来的时候，服务端将不能处理的客户端连接请求放在队列中等待处理，backlog参数指定了队列的大小。

ChannelOption.SO_KEEPALIVE

一直保持连接活动状态

1.9.11 EventLoopGroup和其实现类NioEventLoopGroup

（1）EventLoopGroup是一组EventLoop的抽象，Netty为了更好的利用多核CPU资源，一般会有多个EventLoop同时工作，每个EventLoop维护着一个Selector实例。

（2）EvnetLoopGroup接口，可以从组里面按照一定规划获取其中一个EventLoop来处理任务。在Netty服务器端编程中，我们一般都需要提供两个EventLoopGroup，例如：BossEventLoopGroup和WorkerEventLoopGroup

（3）通常一个服务端口即一个ServerSocketChannel对应一个Selector和一个EventLoop线程。BossEventLoop负责接收客户端的连接并将SocketChannel交给WorkerEventLoopGroup来进行IO处理，如下图：

BossEventLoop通常是一个单线程的EventLoop，EventLoop维护着一个注册了ServerSocketChannel的Selector实例BossEventLoop不断轮询Selector将连接事件分离出来
通常是OP_ACCEPT时间，然后将接收到的ScoketChannel交给WorkerEventLoop
WorkerEventLoop会由next选择其中一个EventLoop来将这个SocketChannel注册到其维护的Selector并对其后续的IO事件进行处理

（4）常用方法

public EioEventLoopGroup()，构造方法
public Future<?> shutdownGracefully()，断开连接，关闭线程

1.10 Unpooled类

（1）Netty提供了一个专门用来操作缓冲区（即Netty的数据容器）的工具类

（2）常用方法如下：

public static ByteBuf copiedBuffer(CharSequence string, Charset charset)

通过给定的数据和字符编码返回一个ByteBuffer对象（类似于NIO中的ByteBuffer，但有区别）

（3）举例说明Unpooled获取Netty的数据容器ByteBuf的基本使用

例子1：

public class NettyByteBuf01 {
    public static void main(String[] args) {
        // 创建一个ByteBuf
        // 1、创建一个对象，该对象包含一个数组arr，是一个byte[10]
        // 2、在netty的buffer中，不需要使用flip进行反转
        //    底层维护了readerIndex和writerIndex
        // 3、0 <= readerIndex <= writerIndex <= capacity
        ByteBuf buffer = Unpooled.buffer(10);
        for (int i = 0; i < 10; i++) {
            buffer.writeByte(i); // writerIndex自增
        }
        // 输出
        for (int i = 0; i < buffer.capacity(); i++) {
//            System.out.println(buffer.getByte(i));
            System.out.println(buffer.readByte()); // readerIndex增加
        }
    }
}

例子2：

public class NettyByteBuf02 {
    public static void main(String[] args) {
        // 使用copiedBuffer创建ByteBuf
        ByteBuf buf = Unpooled.copiedBuffer("hello, world!", Charset.forName("utf-8"));
        // 是否创建了一个数组
        if (buf.hasArray()) {
            byte[] array = buf.array();
            System.out.println(new String(array, Charset.forName("utf-8")));
        }
    }
}

1.11 Netty群聊系统（重点）

要求：

编写一个Netty群聊系统，实现服务器端和客户端之间的数据简单通讯（非阻塞）
实现多人群聊
服务器端：可以监测用户上线、离线，并实现消息转发功能
客户端：通过channel可以无阻塞发送消息给其它所有用户，同时可以接受其它用户发送的消息（有服务器转发得到）

服务端代码：

public class GroupChatServer {

    // 监听端口
    private int port;
    public GroupChatServer(int port) {
        this.port = port;
    }

    // 处理客户端请求
    public void run() throws InterruptedException {
        // 创建两个线程组
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup(); // 默认为CPU线程 * 2
        // 创建ServerBootStrap
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        ChannelFuture channelFuture;
        try {
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            // 获取到pipeline
                            ChannelPipeline pipeline = ch.pipeline();
                            // 添加相关的处理器
                            // 加入解码器
                            pipeline.addLast("decoder", new StringDecoder());
                            // 加入编码器
                            pipeline.addLast("encoder", new StringEncoder());
                            // 加入自己的业务处理handler
                            pipeline.addLast(new GroupChatServerHandler());
                        }
                    });
            System.out.println("netty 群聊服务器启动");
            channelFuture = serverBootstrap.bind(port).sync();
            // 监听关闭
            channelFuture.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }



    }

    public static void main(String[] args) throws Exception {
        new GroupChatServer(7777).run();
    }

}

public class GroupChatServerHandler extends SimpleChannelInboundHandler {

    // 定义一个channel组，用来管理所有的channel用来转发消息
    // GlobalEventExecutor.INSTANCE是一个全局的事件执行器，是一个单例
    private static ChannelGroup channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

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

    // 表示连接建立，一旦连接第一个被执行
    // 将当前channel加入到channelGroup
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        // 将客户加入聊天的信息推送给其它在线的客户端
        // 该方法会将channelGroup中所遇的channel遍历并发送此消息
        channelGroup.writeAndFlush("[客户端]" + channel.remoteAddress() + " 加入聊天\n");
        channelGroup.add(channel);
    }

    // 断开连接，将客户离开信息推送给当前在线的其它客户
    // 执行此方法会自动的将channelGroup中断开连接的channel移除
    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
//        channelGroup.remove(channel);
        channelGroup.writeAndFlush("[客户端]" + channel.remoteAddress() + " 离开聊天\n");
    }

    // 表示channel处于活动状态
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(ctx.channel().remoteAddress() + " 上线了...");
    }

    // 表示channel处于不活动状态
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        System.out.println(ctx.channel().remoteAddress() + " 下线了...");
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        // 获取到当前channel
        Channel channel = ctx.channel();
        // 这时遍历channelGroup，根据不同的情况回送不同的信息
        channelGroup.stream().forEach(ch -> {
            // 不是当前的channel直接转发
            if (ch != channel) {
                ch.writeAndFlush("[客户]" + channel.remoteAddress() + " " + sdf.format(new Date()) + " 发送：" + msg + "\n");
            } else {
                // 回显自己发送的消息，可省略
                ch.writeAndFlush("自己发送了消息：" + msg);
            }
        });
    }

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

客户端代码：

public class GroupChatClient {
    // 属性
    private final String host;
    private final int port;

    public GroupChatClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void run() throws InterruptedException {
        EventLoopGroup eventExecutors = new NioEventLoopGroup();
        Bootstrap bootstrap = new Bootstrap();
        try {
            bootstrap.group(eventExecutors)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            // 得到pipeline
                            ChannelPipeline pipeline = ch.pipeline();
                            // 加入相关的handler
                            pipeline.addLast("decoder", new StringDecoder());
                            pipeline.addLast("encoder", new StringEncoder());
                            // 自定义handler
                            pipeline.addLast(new GroupChatClientHandler());
                        }
                    });
            ChannelFuture channelFuture = bootstrap.connect(host, port).sync();
            // 得到channel
            Channel channel = channelFuture.channel();
            System.out.println("---------  " + channel.localAddress() + "  ------------");
            // 客户端需要输入信息，创建一个扫描器
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNextLine()) {
                String msg = scanner.nextLine();
                // 通过channel发送信息
                channel.writeAndFlush(msg + "\r\n");

            }
            // 给关闭通道进行监听
            channelFuture.channel().closeFuture().sync();
        } finally {
            eventExecutors.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        new GroupChatClient("127.0.0.1", 7777).run();;
    }

}

public class GroupChatClientHandler extends SimpleChannelInboundHandler<String> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        System.out.println(msg.trim());
    }
}

1.12 Netty心跳检测机制

要求：

编写一个Netty心跳检测机制，当服务器超过3秒没有读时，就提示读空闲
当服务器超过5秒没有写操作时，就提示写空闲
当服务器超过7秒没有读或、写操作时，提示读写空闲

服务器代码：

public class MyServer {
    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .handler(new LoggingHandler(LogLevel.INFO)) // 在bossGroup中增加一个日志处理器
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            // 加入一个Netty提供的IdleStateHandler
                            /**
                             * 1、IdleStateHandler是netty提供处理空闲状态的处理器
                             * 2、long readerIdleTime：表示多长时间没有读取，就会发送一个心跳检测包检测是否还是连接状态
                             *    long writerIdleTime：表示多长时间没有写，就会发送一个心跳检测包检测是否还是连接状态
                             *    long allIdleTime：表示多长时间没有读写，就会发送一个心跳检测包检测是否还是连接状态
                             * 3、当IdleStateHandler触发后，就会传递给管道的下一个handler去处理通过调用（触发
下一个handler的userEventTriggered，在该方法中去处理                             */
                            pipeline.addLast(new IdleStateHandler(3, 5, 7, TimeUnit.SECONDS));
                            // 加入一个空闲检测进一步处理的handler
                            pipeline.addLast(new MyServerHandler());
                        }
                    });

            // 启动服务器
            ChannelFuture channelFuture = serverBootstrap.bind(7777).sync();
            channelFuture.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

public class MyServerHandler extends ChannelInboundHandlerAdapter {

    /**
     *
     * @param ctx 上下文
     * @param evt 事件
     * @throws Exception
     */
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent) {
            // evt 向下转型成IdleStateEvent
            IdleStateEvent event = (IdleStateEvent) evt;
            String eventType = null;
            switch (event.state()) {
                case READER_IDLE:
                    eventType = "读空闲";
                    break;
                case WRITER_IDLE:
                    eventType = "写空闲";
                    break;
                case ALL_IDLE:
                    eventType = "读写空闲";
                    break;
            }
            System.out.println(ctx.channel().remoteAddress() + " --超时事件发生：" + eventType);
            System.out.println("服务器进行处理...");
        }
    }
}

1.13 Netty通过WebSocket编程实现长连接

要求：

http协议是无状态的，浏览器和服务器间的请求响应一次，下一次会重新创建连接
实现基于webSocket的长连接的全双工的交互
改变http协议多次请求的约束，实现长连接，服务器可以发送消息给浏览器
客户端浏览器和服务端会相互感知，如服务器关了浏览器会感知，反之同样。

服务器端代码：

public class MyServer {
    public static void main(String[] args) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup(1);
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        try {
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            // 因为基于http协议，使用http的编码解码器
                            pipeline.addLast(new HttpServerCodec());
                            // 以块方式写，添加ChunkedWriteHandler处理器
                            pipeline.addLast(new ChunkedWriteHandler());
                            /**
                             * 1、http数据在传输过工程中是分段的，HttpObjectAggregator就是可以将多个段聚合
                             * 2、当浏览器发送大量数据时，就会因此发出多次http请求
                             */
                            pipeline.addLast(new HttpObjectAggregator(8192));
                            /**
                             * 1、对于websocket，它的数据是以帧（frame）形式传递
                             * 2、浏览器请求时 ws://localhost:7777/hello 表示请求的uri
                             * 3、WebSocketServerProtocolHandler 核心功能将http协议升级为ws协议，保持长连接
                             */
                            pipeline.addLast(new WebSocketServerProtocolHandler("/hello"));
                            // 自定义handler，处理业务逻辑
                            pipeline.addLast(new MyTextWebSocketFrameHandler());
                        }
                    });
            ChannelFuture channelFuture = serverBootstrap.bind(7777).sync();
            channelFuture.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

// TextWebSocketFrame：表示文本帧（frame）
public class MyTextWebSocketFrameHandler extends SimpleChannelInboundHandler<TextWebSocketFrame> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, TextWebSocketFrame msg) throws Exception {
        System.out.println("服务器端收到消息：" + msg.text());
        // 回复消息
        ctx.channel().writeAndFlush(new TextWebSocketFrame("服务器时间 " + LocalDateTime.now() + "：" + msg.text()));

    }

    // 当web客户单连接后触发
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        // LongText是唯一的，而ShortText不是
        System.out.println("handlerAdded 被调用，(LongText)" + ctx.channel().id().asLongText());
        System.out.println("handlerAdded 被调用，(ShortText)" + ctx.channel().id().asShortText());
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
        System.out.println("handlerRemoved 被调用，" + ctx.channel().id().asLongText());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        System.out.println("异常发生 " + cause.getMessage());
        ctx.close(); // 关闭连接
    }
}

客户端页面：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

    <form onsubmit="return false">
        <textarea name="message" style="height: 300px; width: 300px"></textarea>
        <input type="button" value="发送消息" onclick="send(this.form.message.value)">
        <textarea id="responseText" style="height: 300px; width: 300px"></textarea>
        <input type="button" value="清空内容" onclick="document.getElementById('responseText').value=''">
    </form>

</body>
<script>
    var socket;
    // 判断当前浏览器是否支持websocket
    if (window.WebSocket) {
        socket = new WebSocket("ws://localhost:7777/hello");
        // 相当于channelReado，ev收到服务器端回送的消息
        socket.onmessage = function (ev) {
            var rt = document.getElementById("responseText")
            rt.value = rt.value + "\n" + ev.data
        }
        // 相当于连接开启（感知连接开启）
        socket.onopen = function (ev) {
            var rt = document.getElementById("responseText")
            rt.value = "连接开启..."
        }
        // 相当于连接关闭（感知连接关闭）
        socket.onclose = function (ev) {
            var rt = document.getElementById("responseText")
            rt.value = rt.value + "\n连接关闭..."
        }
    } else {
        alert("当前浏览器不支持WebSocket")
    }
    // 发送消息到服务器
    function send(message) {
        // 判断socket是否创建好
        if (!window.socket) {
            return;
        }
        if (socket.readyState == WebSocket.OPEN) {
            // 通过socket发送消息
            socket.send(message)
        } else {
            alert("连接没有开启")
        }
    }
</script>
</html>

yongmingyongye

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Netty深入学习（二）

1、Netty1.1原生NIO存在的问题1）NIO的类库和API繁杂，使用麻烦；需要熟练掌握Selector、ServerSocketChannel、SocketChannel、ByteBuffer等。2）需求具备其他的额外技能：要熟悉Java多线程编程，因为NIO编程涉及到Reactor模式，你必须对多线程和网络编程非常熟悉，才能编写出高质量的NIO程序。3）开发工作量和难度非常大：如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥塞和异常流的处理4）JDK NIO的Bug.
复制链接

扫一扫