同步非阻塞NIO框架Netty示例，以及性能测试数据

已于 2022-06-24 13:55:16 修改
阅读量837 收藏 1
点赞数
分类专栏： 后端相关 文章标签： netty nio 非阻塞 高并发 同步
于 2020-09-02 15:50:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yhj_911/article/details/108363544
版权

最近有一个高并发的项目，经过反复思考，决定采用Netty框架，最后也给出了普通的springboot接口和Netty框架性能的对比。

springboot框架集成Netty框架比较简单，直接上代码
加入依赖

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

追加java代码

package com.jndj.platform.netty;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.net.InetSocketAddress;

/**
 * 实现客户端发送请求，服务器端会返回Hello Netty
 */
public class NettyServer {
    private static final Logger logger = LoggerFactory.getLogger(NettyServer.class);

    public void start(InetSocketAddress socketAddress) {

        // 定义一对线程组（两个线程池）
        // 主线程组，用于接收客户端的链接，但不做任何处理
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        // 定义从线程组，主线程组会把任务转给从线程组进行处理
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            // 服务启动类，任务分配自动处理
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            // 需要去针对一个之前的线程模型（上面定义的是主从线程）
            serverBootstrap.group(bossGroup, workerGroup)
                    // 设置NIO的双向通道
                    .channel(NioServerSocketChannel.class)
                    //子处理器，用于处理workerGroup
                    // 设置chanel初始化器
                    // 每一个chanel由多个handler共同组成管道(pipeline)
                    .childHandler(new NettyServerInitializer())
                    //.localAddress(socketAddress)
                    // 设置队列大小
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    // 两小时内没有数据的通信时,TCP会自动发送一个活动探测数据报文
                    .childOption(ChannelOption.SO_KEEPALIVE, true);

            // 启动
            // 绑定端口，并设置为同步方式，是一个异步的chanel
            ChannelFuture future = serverBootstrap.bind(8888).sync();
            logger.info("服务器启动开始监听端口: {}", socketAddress.getPort());

            // 关闭
            // 获取某个客户端所对应的chanel，关闭并设置同步方式
            future.channel().closeFuture().sync();
        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            //使用一种优雅的方式进行关闭
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}


package com.jndj.platform.netty;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;

/**
 * 这是一个初始化器，chanel注册后会执行里面相应的初始化方法(也就是将handler逐个进行添加)
 */
public class NettyServerInitializer extends ChannelInitializer<SocketChannel>{
    // 对chanel进行初始化
    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        // 通过socketChannel去获得对应的管道
        ChannelPipeline channelPipeline = socketChannel.pipeline();
        // pipeline中会有很多handler类（也称之拦截器类）
        // 获得pipeline之后，可以直接.add，添加不管是自己开发的handler还是netty提供的handler
        // 一般来讲添加到last即可，添加了一个handler并且取名为HttpServerCodec
        // 当请求到达服务端，要做解码，响应到客户端做编码
        channelPipeline.addLast("HttpServerCodec", new HttpServerCodec());
//        channelPipeline.addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));
//        channelPipeline.addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));
        // 添加自定义的CustomHandler这个handler，返回Hello Netty
        channelPipeline.addLast("NettyServerHandler", new NettyServerHandler());
    }
}


package com.jndj.platform.netty;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.HttpHeaderNames;
import io.netty.handler.codec.http.HttpObject;
import io.netty.handler.codec.http.HttpRequest;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.util.CharsetUtil;

/**
 * 创建自定义助手类
 * 处理的请求是：客户端向服务端发起送数据，先把数据放在缓冲区，服务器端再从缓冲区读取，类似于[ 入栈, 入境 ]
 */
public class NettyServerHandler extends SimpleChannelInboundHandler<HttpObject>{//Http请求，所以使用HttpObject

    @Override
    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
//        System.out.println("channel注册");
        super.channelRegistered(ctx);
    }

    @Override
    public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
//        System.out.println("channel注册");
        super.channelUnregistered(ctx);
    }

    /**
     * 客户端连接会触发
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
//        System.out.println("channel活跃状态");
        super.channelActive(ctx);
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
//        System.out.println("客户端与服务端断开连接之后");
        super.channelInactive(ctx);
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        System.out.println("channel读取数据完毕");
        super.channelReadComplete(ctx);
    }

    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
//        System.out.println("用户事件触发");
        super.userEventTriggered(ctx, evt);
    }

    @Override
    public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
//        System.out.println("channel可写事件更改");
        super.channelWritabilityChanged(ctx);
    }

    /**
     * 发生异常触发
     * channel发生异常，若不关闭，随着异常channel的逐渐增多，性能也就随之下降
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
//        System.out.println("捕获channel异常");
        super.exceptionCaught(ctx, cause);
    }

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
//        System.out.println("助手类添加");
        super.handlerAdded(ctx);
    }

    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
//        System.out.println("助手类移除");
        super.handlerRemoved(ctx);
    }

    /**
     * ChannelHandlerContext：上下文对象
     */
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {
        //获取当前channel
        Channel currentChannel = ctx.channel();

        //判断msg是否为一个HttpRequest的请求类型
        if(msg instanceof HttpRequest) {

            // 客户端远程地址
//            System.out.println(currentChannel.remoteAddress());
            /**
             *
             * 未加判断类型，控制台打印的远端地址如下：
             *
             /0:0:0:0:0:0:0:1:5501
             /0:0:0:0:0:0:0:1:5501
             /0:0:0:0:0:0:0:1:5502
             /0:0:0:0:0:0:0:1:5502
             *
             * 原因是接收的MSG没有进行类型判断
             *
             * 增加了判断，为何还会打印两次？
             *
             /0:0:0:0:0:0:0:1:5605
             /0:0:0:0:0:0:0:1:5605
             *
             * 打开浏览器的network会发现，客户端对服务端进行了两次请求：
             * 	1、第一次是所需的
             *  2、第二次是一个icon
             *  因为没有加路由（相当于Springmvc中的requestMapping），只要发起请求，就都会到handler中去
             *
             */

            //在Linux中也可以通过CURL 本机Ip:端口号 发送请求（只打印一次，干净的请求）

            // 定义发送的消息（不是直接发送，而是要把数据拷贝到缓冲区，通过缓冲区）
            // Unpooed：是一个专门用于拷贝Buffer的深拷贝，可以有一个或多个
            // CharsetUtil.UTF_8：Netty提供
            ByteBuf content = Unpooled.copiedBuffer("Hello Netty", CharsetUtil.UTF_8);

            // 构建一个HttpResponse，响应客户端
            // HttpVersion.HTTP_1_1：默认开启keep-alive
            FullHttpResponse response =
                    new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, content);
            // 设置当前内容长度、类型等
            response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain");
            // readableBytes：可读长度
            response.headers().set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());

            // 通过长下文对象，把响应刷到客户端
            ctx.writeAndFlush(response);
        }
    }
}


package com.jndj.platform;

import com.jndj.platform.netty.NettyServer;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

import java.net.InetSocketAddress;

@SpringBootApplication
@EnableScheduling
public class PlatformApplication {

    public static void main(String[] args) {
        SpringApplication.run(PlatformApplication.class, args);
        //启动服务端
        NettyServer nettyServer = new NettyServer();
        nettyServer.start(new InetSocketAddress("127.0.0.1", 8888));
    }
}

运行后结果
在这里插入图片描述
使用postman测试一下高并发下的性能，并且也写了一个简单的springboot的api，进行了对比测试
10000次请求，间隔1ms的并发

Netty的性能结果，大部分响应时间在2ms，3ms，速度还是挺快的。
在这里插入图片描述
普通的springboot接口，接口响应速度大体在5ms到10ms之间
在这里插入图片描述

最后结论，明显看出使用了NIO的Netty框架速度更快

姚华军
关注
专栏目录
高性能NIO框架Netty入门篇
u010889990的专栏
03-19 2575
Netty介绍 Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。 也就是说，Netty 是一个基于NIO的客户、服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户，服务端应用。Netty相当简化和流线化了网络应用的编程开发过程，例如...
Netty系列之Netty高性能之道
cpongo5
05-29 5356
1. 背景\\1.1. 惊人的性能数据\\最近一个圈内朋友通过私信告诉我，通过使用Netty4 + Thrift压缩二进制编解码技术，他们实现了10W TPS（1K的复杂POJO对象）的跨节点远程服务调用。相比于传统基于Java序列化+BIO（同步阻塞IO）的通信框架，性能提升了8倍多。\\事实上，我对这个数据并不感到惊讶，根据我5年多的NIO编程经验，通过选择合适的NIO框架，加上高性能的压缩二...
Spring Boot 和 Netty
最新发布
weixin_40685746的博客
08-27 47
Spring Boot 和 Netty 是两个强大的工具，它们各自有不同的用途和优势，但可以结合使用来构建高性能的网络应用。下面将详细介绍 Spring Boot 和 Netty，以及它们如何结合使用。Spring Boot 简介 Spring Boot 是一个开源框架，基于 Spring 框架，用于简化 Spring 应...
Netty性能测试
11-12
从测试结果看，Netty性能是非常高的，在所有使用默认配置的情况下，单台服务器能够达到4万次请求解析，作为RPC框架是足够用的。
8-「季淳卿」NIO New (Non-Blocking IO) 同步非阻塞IO 案例
季淳卿的博客
03-15 1319
java大型游戏和服务器都是基于NIO，由选择器选择那个时间段对那个通道进行操作 1.2.1 Channel 通道，渠道 - 不管是那种媒介，都可以用Channel通道 - <是双向通道，即可输出，也可输入> 1.2.2 Buffer 缓冲区（难理解） - 所有通道都写在Buffer里面 - - 专门在NIO中保存数据（存放数据的地方） Buffer创建有两种方式 allocate 在堆空间分配数据空间 （new一个区域给buffer） java全部的对象都是放在堆空间，而堆空间是运行
基于Netty的Comet测试及调优
freeway2000
08-02 401
  测试环境：   服务器 1台   OS: Red Hat Enterprise Linux Server release 5.4   CPU: 4xIntel(R) Xeon(R) CPU E5450 @ 3.00GHz   MEMORY:4G 客户端5台，配置同服务器 上述的测试环境都是采用的虚拟机，而且虚拟机性能不是很好，所以我主要是测连接数，其中有涉及到性能的地方不具...
网络通信框架——Netty示例
蒋含竹的博客
12-27 2516
文章目录网络通信框架——Netty示例概述Server/Client 聊天示例 网络通信框架——Netty示例 概述 Netty 是基于NIO封装的网络通信库，相较于Java原生IO库来说具有以下优点 API封装性好 简单、易用 功能强大，提供了各种常用库的接口 Server/Client 聊天示例 Maven依赖 pom.xml <dependency> &lt...
NIO Netty框架
04-18
NIO（Non-blocking I/O）框架是一种高性能的I/O模型，Netty和Mina都是基于NIO的框架。Netty和Mina都是Java开发的高性能网络框架，供开发者快速构建高性能的网络应用程序。下面是关于Netty和Mina的详细知识点： 开发...
Java NIO与Netty框架深度对比：揭秘性能优化策略
![Java NIO与Netty框架深度对比：揭秘性能优化策略]...# 1. Java NIO和Netty框架概述 ## 1.1 Java N
nio-samples:Java NIO库使用示例
05-18
相同的回显服务器，但使用Netty框架。 相同的回显服务器，但使用NIO2异步通道。 创建10000个客户端连接的类，您可以在nio服务器上测试负载。 监视服务API的简单用法。 监视预定义目录中的更改的类。 您可以播放...
netty框架，服务端、客户端代码示例
11-04
简单的netty框架示例，代码中有完整的注释，代码包含服务端跟客户端代码，RunServer服务端测试类，RunClient客户端测试类
SimpleSocket:Netty 示例项目
07-10
1. **Netty 框架**：Netty 是一个基于 NIO（非阻塞 I/O）的 Java 框架，提供了高度定制的事件循环（EventLoop）、通道（Channel）和管道（ChannelPipeline）机制，使得编写高性能、异步的网络应用变得简单。...
Netty是基于NIO实现的？Netty都是异步的？彻底记住什么是Netty
+W❤：bjmsb2019
08-15 1812
一、Netty 简介 Netty 是基于 Java NIO 的异步事件驱动的网络应用框架，使用 Netty 可以快速开发网络应用，Netty 提供了高层次的抽象来简化 TCP 和 UDP 服务器的编程，但是你仍然可以使用底层的 API。 Netty 的内部实现是很复杂的，但是 Netty 提供了简单易用的API从网络处理代码中解耦业务逻辑。Netty 是完全基于 NIO 实现的，所以整个 Netty 都是异步的。 Netty 是最流行的 NIO 框架，它已经得到成百上千的商业、商用项目验证，许多框架和
Netty实现IM系统的性能测试方案思考
全栈工程师，热爱编程，喜欢探索各种技术栈。分享前端、后端、数据库等技术学习心得，以及在项目开发中的实践经验。
06-07 499
即时通讯（IM）系统是现代应用中非常常见的功能，实现IM系统需要高效、稳定的网络通信框架。Netty作为一个高性能的、异步事件驱动的网络应用框架，广泛应用于各种网络应用中。本文将讨论使用Netty实现IM系统的性能测试方案，旨在为开发者提供有效的测试方法，确保系统的高效性和稳定性。
同步非阻塞IO例子_晏无心_新浪博客
晏无心的博客
07-20 267
同步非阻塞IO是指在进行IO读写时，可以立即返回，不用阻塞等待read、write完全结束。 java实现同步非阻塞IO需要使用Java NIO技术。 先来看server端： 使用iava nio的ServerSocketChannel，设置 serverChannel.configureBlocking(true); 是为了方便测试，serverSocket阻塞的等待客户端的连接，连...
一个例子理解同步-异步、阻塞-非阻塞
longzhongxiaoniao的博客
12-27 546
在编程进阶中，往往很多程序员会碰到同步异步，还有阻塞与非阻塞，这些概念往往容易混淆，下面我将通过一个例子来详细说明他们之间的差别。 我们可以联想这样一个场景张三平时爱喝茶，现在他要去烧开水，即概括为： 张三，废话不多说，煮开水。 出场人物：张三，水壶两把（普通水壶，简称水壶；会响的水壶，简称响水壶）。 1 张三把水壶放到火上，立等水开。（同步阻塞） 张三觉得自己有点傻 2 张三把水壶放...
Netty框架多人聊天案例,代码示例
苏凯的博客
02-02 1719
                                         Netty框架多人聊天案例,代码示例 pom &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3....
40 - 案例分析（二）：高性能网络应用框架Netty
pizicai007的博客
07-19 315
案例分析（二）：高性能网络应用框架Netty1. 网络编程性能的瓶颈2. Reactor 模式3. Netty 中的线程模型4. 用 Netty 实现 Echo 程序服务端.5. 总结   Netty 是一个高性能网络应用框架，应用非常普遍，目前在 Java 领域里，Netty 基本上成为网络程序的标配了。Netty 框架功能丰富，也非常复杂，今天我们主要分析 Netty 框架中的线程模型，而线程模型直接影响着网络程序的性能。      在介绍 Netty 的线程模型之前，我们首先需要把问题搞清楚，了解网络
深入理解Netty：基于Java NIO的高性能网络应用框架
这部分介绍了 Netty 和 Java NIO (非阻塞 I/O) API 的关系，帮助读者理解 Netty 如何利用 Java NIO 提供的机制来实现高效率的网络编程。第2章引导读者创建第一个 Netty 应用程序，而第3章则深入讲解 Netty 的基础...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值