netty——Channl的常用方法、ChannelFuture、CloseFuture

最新推荐文章于 2023-05-31 10:07:00 发布
最新推荐文章于 2023-05-31 10:07:00 发布
阅读量5.6k 收藏 5
点赞数 2
分类专栏： java笔记 文章标签： 服务器 java 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44027353/article/details/121332486
版权

文章目录

Channel

Channel的常用方法

  • close() 关闭channel
  • closeFuture() 处理关闭channel后要执行的操作
    • sync()方法是同步等待channel的关闭
    • addListener()方法是异步等待channel的关闭
  • pipeline()添加处理器
  • write() 将数据写入，netty里面其实还有一个缓冲区，当我们执行flush()方法后或者是缓冲区中数据达到一个数量了就会将缓冲区的数据发送出去
  • writeAndFlush() 将数据写入并刷出

ChannelFuture

解决客户端连接服务器 connect()方法 异步非阻塞 问题

一个普通netty客户端的代码如下

public class HelloClient2 {
    public static void main(String[] args) throws InterruptedException {

        ChannelFuture channelFuture = new Bootstrap()
                .group(new NioEventLoopGroup())
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<NioSocketChannel>() {
                    @Override
                    protected void initChannel(NioSocketChannel socketChannel) throws Exception {
                        socketChannel.pipeline().addLast(new StringEncoder());
                    }
                })
                // 连接服务器  该方法返回的就是ChannelFuture
                .connect("localhost", 8080);

        // 这个sync()方法必须调用，如果不调用直接运行的话，下面发送给服务器的数据没有发送成功
        channelFuture.sync();
        Channel channel = channelFuture.channel();
        channel.writeAndFlush("aaa");
    }
}

为什么调用该方法channelFuture.sync();就能发送数据成功嘞？

这是因为上面一行连接服务器的代码.connect("localhost", 8080); 该方法是异步非阻塞的，主线程发起了连接服务器的操作，但是连接服务器是NioEventLoopGroup中的一个线程执行，如果不调用sync()方法就会出现还没有连接成功服务器，就执行了获取channel的语句并通过获取的channel发送数据，

以后我们看到Future 或者是 Promise 的类型都是和异步方法配套使用的，他俩的用途就是正确处理结果

上面出现了问题，解决方法也有几种：

  • 第一种就是调用ChannelFuture类中的sync()方法，主线程就会阻塞，当客户端与服务器连接成功后才会往下面执行，

  • 第二种解决 调用addListener() 异步处理结果

public static void main(String[] args) throws InterruptedException {

        ChannelFuture channelFuture = new Bootstrap()
                .group(new NioEventLoopGroup())
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<NioSocketChannel>() {
                    @Override
                    protected void initChannel(NioSocketChannel socketChannel) throws Exception {
                        socketChannel.pipeline().addLast(new StringEncoder());
                    }
                })
                // 连接服务器  该方法返回的就是ChannelFuture  该方法是异步非阻塞的
                .connect("localhost", 8080);

        // 第一种解决方法，方法同步处理结果，这里阻塞住，等客户端与服务器连接成功后在往下执行
//        channelFuture.sync();
//        Channel channel = channelFuture.channel();
//        channel.writeAndFlush("aaa");

// 第二种解决 调用addListener() 异步处理结果，上面的同步处理结果是主线程等另一个线程连接成功后再自己拿到连接成功的结果channel
// 然后自己发送数据。而这里的异步是主线程完全就是甩手掌柜，通过channel发送数据也让其他线程来做，主线程只是提供一个回调对象
// 当客户端与服务器连接成功后，EventLoop会自动调用ChannelFutureListener对象中的operationComplete()方法。
        channelFuture.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture channelFuture) throws Exception {
                // 我们可以通过ChannelFuture对象获取channel对象 然后再发送数据
                Channel channel = channelFuture.channel();
                channel.writeAndFlush("客户端通过addListener()方法发送的数据");
            }
        });
    }

CloseFuture

处理客户端与服务器断开连接后，channel关闭后 还想执行的代码

package com.hs.nettyPrimary;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringEncoder;
import lombok.extern.slf4j.Slf4j;

import java.util.Scanner;

/**
 * 处理客户端与服务器断开连接后，channel关闭后 还想执行的代码
 * 业务需求是：
 * 客户端获取用户控制台的输入，输入的数据都发送给服务器端，当输入Q的时候就表示停止数据的发送
 * 然后关闭channel，在channel关闭后再执行一段代码。
 * @author hs
 * @date 2021/07/18
 */
@Slf4j
public class HelloClient3 {
    public static void main(String[] args) throws InterruptedException {

        ChannelFuture channelFuture = new Bootstrap()
                .group(new NioEventLoopGroup())
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<NioSocketChannel>() {
                    @Override
                    protected void initChannel(NioSocketChannel socketChannel) throws Exception {
                        socketChannel.pipeline().addLast(new StringEncoder());
                    }
                })
                // 连接服务器
                .connect("localhost", 8080);

        channelFuture.sync();
        Channel channel = channelFuture.channel();
        log.debug("{}",channel);

        // 新开一个线程来处理客户端发送数据给服务器
        new Thread(()->{
            Scanner scanner = new Scanner(System.in);
            while (true){
                String line = scanner.nextLine();
                if ("Q".equals(line)){
                    channel.close();
                    // 这里也不行，因为close()方法是异步非阻塞的，关闭需要时间，这会出现关闭后的操作在关闭前执行
                    // log.debug("这里channel关闭后的操作！！");
                    break;
                }else{
                    channel.writeAndFlush(line);
                }
            }
        }).start();

        // 写在这里肯定不行，因为这里主线程会执行的 ，那就写在上面一个线程里面嘞？
        // log.debug("这里channel关闭后的操作！！");

    }
}

上面只是完成了获取控制台的输入并发送给服务器，如果输入Q就channel关闭，但是channel关闭后的的代码执行 还没有实现。

先多添加一个handler，是日志相关的，主要是方便看清控制台更多的输出

// 多加一个handler 是日志信息相关的
socketChannel.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));

正在的解决方法其实就是通过channel获取一个CloseChannel对象，然后选择同步或者是异步的方式来处理

@Slf4j
public class HelloClient3 {
    public static void main(String[] args) throws InterruptedException {

        ChannelFuture channelFuture = new Bootstrap()
                .group(new NioEventLoopGroup())
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<NioSocketChannel>() {
                    @Override
                    protected void initChannel(NioSocketChannel socketChannel) throws Exception {
                        // 多一些日志信息
                        socketChannel.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                        socketChannel.pipeline().addLast(new StringEncoder());
                    }
                })
                // 连接服务器
                .connect("localhost", 8080);

        channelFuture.sync();
        Channel channel = channelFuture.channel();
        log.debug("{}",channel);

        // 新开一个线程来处理客户端发送数据给服务器
        new Thread(()->{
            Scanner scanner = new Scanner(System.in);
            while (true){
                String line = scanner.nextLine();
                if ("Q".equals(line)){
                    channel.close();
                    break;
                }else{
                    channel.writeAndFlush(line);
                }
            }
        },"input").start();

        // 正确实现channel关闭后要执行的业务逻辑
        // 1. 要获取一个 CloseFuture对象，同样它也有同步处理关闭和异步处理关闭两种方式
        ChannelFuture closeFuture = channel.closeFuture();
        // 2. 同步处理关闭 ,这里会将主线程阻塞，等channel关闭后才会继续往下执行
//        log.debug("wait Channel close....");
//        closeFuture.sync();
//        log.debug("channel关闭后操作");
        
        // 2. 异步处理，异步处理，上面真正执行关闭channel的EventLoop线程 成功关闭channel后就会调用这里面的方法
        closeFuture.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture channelFuture) throws Exception {
                log.debug("channel关闭后操作");
            }
        });
    }
}

上面还存在一个问题，那就是当channel已经关闭后，但是客户端这边的程序还在执行，这是因为虽然我们创建的线程已经关闭了，但是NioEventloopGroup里面还有一些线程还在执行，下面进行优雅的关闭。

  1. 首先是把创建NioEventloopGroup对象的地方往前移，而不是像之前一样使用匿名对象。

  2. 然后在channel关闭后的语句中调用nioEventLoopGroup.shutdownGracefully()方法，优雅的关闭 Gracefully就是优雅的意思

package com.hs.nettyPrimary;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import lombok.extern.slf4j.Slf4j;

import java.util.Scanner;

/**
 * 处理客户端与服务器断开连接后，channel关闭后 还想执行的代码
 * 业务需求是：
 * 客户端获取用户控制台的输入，输入的数据都发送给服务器端，当输入Q的时候就表示停止数据的发送
 * @author hs
 * @date 2021/07/17
 */
@Slf4j
public class HelloClient3 {
    public static void main(String[] args) throws InterruptedException {

        // 把创建NioEventLoopGroup对象的语句往前移
        NioEventLoopGroup nioEventLoopGroup = new NioEventLoopGroup();
        ChannelFuture channelFuture = new Bootstrap()
                .group(nioEventLoopGroup)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<NioSocketChannel>() {
                    @Override
                    protected void initChannel(NioSocketChannel socketChannel) throws Exception {
                        // 多添加一个handler 是日志信息相关的
                        socketChannel.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                        socketChannel.pipeline().addLast(new StringEncoder());
                    }
                })
                // 连接服务器
                .connect("localhost", 8080);

        channelFuture.sync();
        Channel channel = channelFuture.channel();
        log.debug("{}",channel);

        // 新开一个线程来处理客户端发送数据给服务器
        new Thread(()->{
            Scanner scanner = new Scanner(System.in);
            while (true){
                String line = scanner.nextLine();
                if ("Q".equals(line)){
                    channel.close();
                    break;
                }else{
                    channel.writeAndFlush(line);
                }
            }
        },"input").start();

        // 正确实现channel关闭后要执行的业务逻辑
        // 1. 要获取一个 CloseFuture对象，同样它也有同步处理关闭和异步处理关闭两种方式
        ChannelFuture closeFuture = channel.closeFuture();
        // 2. 异步处理，上面真正执行关闭channel的EventLoop线程 成功关闭channel后就会调用这里面的方法
        closeFuture.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture channelFuture) throws Exception {
                log.debug("channel关闭后操作");
                nioEventLoopGroup.shutdownGracefully();
            }
        });
    }
}

小疑问，为什么netty要用异步？就比如让客户端的主线程去创建连接，创建连接成功后再继续往下执行，这里单线程不也是可以吗？那么为什么要使用异步嘞？

这里netty采用异步的方式提升的是吞吐量，并不是响应时间，比如下面一个例子

在这里插入图片描述

然后将看病细分，每个步骤花费五分钟
在这里插入图片描述

接下来，每个医生就仅仅处理一个步骤

在这里插入图片描述

以前一个医生一个小时只能接待4个病人，但现在一个小时可以接待12个病人了

要点：

  • 异步没有缩短响应时间，反而有所增加
  • 异步提升的是吞吐量，增加单位时间内处理请求的个数
  • 需要合理进行任务的拆分
  • 异步必须配合多线程，多核cpu。

胡尚
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Netty——基本使用介绍
02-24
在对通信模型有了基本的认识时，学习到的仅仅是一个模型，如果想把这些真正的用于实际工作中，那么还需要不断的完善、扩展和优化。比如经典的TCP读包写包问题，或者是数据接收的大小，实际的通信处理与应答的处理逻辑等等一些细节问题需要认真的去思考，而这些都需要大量的时间和经历，以及丰富的经验。所以想学好Socket通信不是件容易事，那么接下来就来学习一下新的技术Netty，为什么会选择Netty？因为它简单！使用Netty不必编写复杂的逻辑代码去实现通信，再也不需要去考虑性能问题，不需要考虑编码问题，半包读写等问题。强大的Netty已经帮我们实现好了，我们只需要使用即可。Netty是最流行的NIO框架，
java网络编程基础—Netty框架应用基础
sigou389的博客
09-20 284
缘由： 在最近的一段时间中，一直没有对java网络编程有了解，只知道socket的大概却又说不清楚，但常规的socket编程已经不适合现在的开发了，于是我去了解了有什么java网络框架能减少网络编程的难度。其实有2个，Mina与Netty，热门的rpc框架dubbo的网络通信部分就是用这2者实现的（使用时选择使用其中一个）。但Netty的社区还在活跃，所以还是选择去了解了Netty框架，把《Ne...
spring+netty服务器搭建的方法
08-28
本篇文章主要介绍了spring+netty服务器搭建的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
springboot+netty实现mqtt协议的broken
最新发布
11-09
可将此代码当做微服务中的一个服务，定制化自己的需求
通过入门demo简单了解netty使用方法
08-25
主要介绍了通过入门demo简单了解netty使用方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Netty框架之ChannelFuture和CloseFuture异步处理连接和断开
TheWayForDream
05-01 2727
一.ChannelFuture异步处理连接请求 1.说到异步处理，先从同步阻塞处理连接请求讲起 public static void main(String[] args) { //bootstrap客户端启动器，启动客户端，绑定各个组件 Bootstrap bootstrap = new Bootstrap(); //设置NioEventLoopGroup作为Woker线程组处理IO读写请求,这里因为客户端不需要处理连接请求，所以不需要NioEventLoo
【Netty】从0到1（八）：入门-ChannelFuture 与 CloseFuture
BASK2311的博客
05-31 405
往期系列文章请访问博主的。
netty中future.channel().closeFuture().sync()作用
热门推荐
大米饭
08-25 1万+
future.channel().closeFuture().sync() 执行完 会使主线程 wait 阻塞后续逻辑执行 我们看下官方的入门例子： 启动一个nettyserver，监听8088端口，再通过命令行执行telnet localhost 8088来连接。 完整的例子请参考之前的入门例子介绍：Netty入门官方例子解析（一）丢弃服务器《入门例子，不返回消息》章节 public class DiscardServer { try { .
netty之channel详解
小尘_OnMyWay的博客
04-04 2637
文章目录Channelchannel的主要作用channel异步连接处理--channelFuturechannel异步关闭处理--CloseFuture优雅的关闭程序 Channel channel的主要作用 close()：关闭channel closeFuture()：处理channel的关闭 sync 同步等待channel关闭 addListener 异步等待channel关闭 pipeline()：添加处理器 write()：将数据写入 writeAndFlush()：将数据写入并刷出
Netty 框架学习 —— 第一个 Netty 应用（csdn）————程序.pdf
12-03
Netty 框架学习 —— 第一个 Netty 应用（csdn）————程序
Netty成长之路——初始Netty
12-21
前言       初始Netty框架是在一家电商公司，开发微信应用小程序，解决客服聊天系统消息使用方案时用到的。在此之前，也仅仅是了解过它，写过一些demo而已，从未深入学习过。这次因为研发的产品需要，有幸再次学习它，索性我就搞个透。言规正传，我们这就开始。 1、Netty简介 Netty 是一个基于NIO的客户端、服务端的编程框架，使用Netty可以确保你快速和简单的开发出一个网络应用，Netty相当于简化和流线化了网络应用的编程开发过程，Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。它的体系结构图如下： 2、Netty特性
dubbo——rpc的原理和netty1
08-04
（1）服务消费方(client)调用以本地调用方式调用服务 （2）client stub接收到调用后负责将方法、参数组装成能够进行网络传输的消 （3）clien
Netty源码解析（三）bind方法（二）
01-07
流程走到了启动好reactor线程后，ServerSocketChannel注册到selector上，但是感兴趣事件填的0,我们继续跟流程，走到这里，initAndRegister方法完成，继续跟bind方法，我们看bind方法中的doBind0方法 /** * * @...
spring boot整合netty的实现方法
08-25
主要介绍了spring boot整合netty的实现方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Netty入门教程文档
03-27
Netty入门教程
netty+4G DTU
03-08
netty+4G DTU
使用netty进行rtsp服务端开发.zip
01-02
使用netty进行rtsp服务端开发 一个使用netty写的rtsp服务器。 目前支持H264、H265、 AAC格式的流文件上传与存储。 H264、H265、AAC格式流文件的播放
Netty大纲-同步netty专栏
07-07
Netty大纲-同步netty专栏
详细解释下netty中channelRead方法
05-25
在Netty中，`channelRead`方法是ChannelInboundHandler的一个方法，用于处理从网络中读取到的数据。 当Netty从网络中读取到数据时，会自动调用ChannelInboundHandler的`channelRead`方法。该方法的参数是一个`ChannelHandlerContext`对象和一个`Object`类型的数据，表示当前的处理上下文和读取到的数据。 在`channelRead`方法中，我们可以对读取到的数据进行解码、处理、编码等操作，并将处理后的数据传递给下一个ChannelInboundHandler处理，或者直接将数据发送回网络中。 需要注意的是，`channelRead`方法默认不会释放读取到的消息，需要手动调用`ReferenceCountUtil.release(msg)`方法来释放消息，否则可能会导致内存泄漏。 另外，如果发生异常，可以在`channelRead`方法中捕获并进行处理，也可以将异常传递给下一个ChannelInboundHandler处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值