简介
Netty是一个基于Java的开源网络应用框架，它提供了高性能、异步事件驱动的网络编程能力。Netty旨在帮助开发者构建高性能、高可靠性的网络应用程序。
Netty提供了简洁的API和丰富的功能，可以轻松处理各种网络通信协议，如TCP、UDP、WebSocket等。它的设计理念是基于事件驱动和回调机制，而不是传统的线程模型，这使得它可以实现高并发、低延迟的网络通信。
通过使用Netty，开发者可以方便地处理复杂的网络通信逻辑，例如请求-响应模式、长连接、心跳检测等。Netty提供了灵活的编解码器和处理器，可以对网络数据进行高效的编解码和处理。同时，Netty还提供了可靠的错误处理机制和事件机制，方便开发者进行异常处理和扩展。
Netty特点
-
高性能
Netty采用了基于事件驱动的异步模型，通过使用非阻塞I/O操作和多线程处理请求，实现了高性能的网络通信。
-
高可靠性
Netty提供了一套强大的错误处理机制，包括异常处理、断线重连、心跳检测等，可以有效地处理网络中的各种异常情况，提高应用程序的可靠性。
-
高可扩展性
Netty的设计模式和组件化架构使得它非常易于扩展和定制。开发人员可以根据自己的需求，选择合适的组件和模块，构建出符合自己业务需求的网络应用程序。
-
支持多种协议
Netty支持多种常用的网络协议，包括HTTP、WebSocket、TCP、UDP等，可以满足不同场景下的网络通信需求。
实例
版本依赖
| 模块 | 版本号 |
|---|---|
| JDK | 17 |
| SpringBoot | 3.1.0 |
| Netty | 4.1.90.Final |
引入依赖
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>springboot-netty</artifactId>
<name>${project.artifactId}</name>
<version>1.0-SNAPSHOT</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.1.0</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<properties>
<java.version>17</java.version>
<maven.version>17</maven.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- 引入Netty依赖 -->
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.90.Final</version>
</dependency>
</dependencies>
EchoServer
// 创建Server端
EventLoopGroup workGroup = new NioEventLoopGroup();
final EchoServerHandler serverHandler = new EchoServerHandler();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(workGroup)
.channel(NioServerSocketChannel.class)
.handler(new LoggingHandler(LogLevel.INFO))
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
p.addLast(new LoggingHandler(LogLevel.INFO));
p.addLast(serverHandler);
}
});
// 绑定端口
ChannelFuture f = b.bind(8088).sync();
// 等待连接关闭
f.channel().closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 关闭所有线程
workGroup.shutdownGracefully();
}
EchoServerHandler
@Sharable
public class EchoServerHandler extends ChannelInboundHandlerAdapter {
/**
* 读取
*
* @param ctx
* @param msg
* @throws Exception
*/
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ctx.write(msg);
}
/**
* 读取完毕时
*
* @param ctx
* @throws Exception
*/
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.flush();
}
/**
* 抓住异常
*
* @param ctx
* @param cause
* @throws Exception
*/
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}
EchoClient
EventLoopGroup group = new NioEventLoopGroup();
EchoClientHandler clientHandler = new EchoClientHandler();
try {
Bootstrap b = new Bootstrap();
b.group(group)
.channel(NioSocketChannel.class)
.option(ChannelOption.TCP_NODELAY, true)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
p.addLast(new LoggingHandler(LogLevel.INFO));
p.addLast(clientHandler);
}
});
// 连接server端
ChannelFuture cf = b.connect("127.0.0.1", 8088).sync();
// 等待连接关闭
cf.channel().closeFuture().sync();
} catch (Exception e) {
e.printStackTrace();
} finally {
group.shutdownGracefully();
}
EchoClientHandler
@Sharable
public class EchoClientHandler extends ChannelInboundHandlerAdapter {
private final ByteBuf firstMsg;
public EchoClientHandler() {
firstMsg = Unpooled.wrappedBuffer("Hello Netty Socket Codeing".getBytes(StandardCharsets.UTF_8));
}
/**
* 通道活跃时
*
* @param ctx
* @throws Exception
*/
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
// 第一次传输
ctx.writeAndFlush(firstMsg);
}
/**
* 读取数据时
*
* @param ctx
* @param msg
* @throws Exception
*/
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ctx.write(msg);
}
/**
* 读取完毕时
*
* @param ctx
* @throws Exception
*/
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
// 延迟3秒
TimeUnit.SECONDS.sleep(3);
ctx.flush();
}
/**
* 捕获到异常时
*
* @param ctx
* @param cause
* @throws Exception
*/
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}
测试
先启动EchoServer，再启动EchoClient
18:36:39.872 [nioEventLoopGroup-2-1] INFO io.netty.handler.logging.LoggingHandler -- [id: 0xe21b38be, L:/127.0.0.1:54127 - R:/127.0.0.1:8088] WRITE: 26B
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 65 6c 6c 6f 20 4e 65 74 74 79 20 53 6f 63 6b |Hello Netty Sock|
|00000010| 65 74 20 43 6f 64 65 69 6e 67 |et Codeing |
+--------+-------------------------------------------------+----------------+
18:36:39.872 [nioEventLoopGroup-2-1] INFO io.netty.handler.logging.LoggingHandler -- [id: 0xe21b38be, L:/127.0.0.1:54127 - R:/127.0.0.1:8088] READ COMPLETE
18:36:42.882 [nioEventLoopGroup-2-1] INFO io.netty.handler.logging.LoggingHandler -- [id: 0xe21b38be, L:/127.0.0.1:54127 - R:/127.0.0.1:8088] FLUSH
18:36:42.885 [nioEventLoopGroup-2-1] INFO io.netty.handler.logging.LoggingHandler -- [id: 0xe21b38be, L:/127.0.0.1:54127 - R:/127.0.0.1:8088] READ: 26B
HttpServer (HTTP服务)
// 主从模式
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.handler(new LoggingHandler(LogLevel.INFO))
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
// HTTP 模式
ChannelPipeline p = ch.pipeline();
p.addLast(new HttpServerCodec());
p.addLast(new HttpServerExpectContinueHandler());
p.addLast(new HttpServerHandler());
}
});
ChannelFuture ch = b.bind(8089).sync();
System.out.println("Open Http Server : http://127.0.0.1:8089");
ch.channel().closeFuture().sync();
} catch (Exception ex) {
ex.printStackTrace();
} finally {
workerGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
}
测试Http
访问链接：http://127.0.0.1:8089
hello netty http coding
总结
本文介绍了Spring Boot和Netty的基本概念和特点。然后，它详细解释了如何在Spring Boot项目中添加Netty依赖项，并配置Netty服务器。接下来，文章介绍了如何创建一个简单的Netty处理器，用于处理传入的网络请求。然后，它展示了如何在Spring Boot应用程序中使用这个Netty处理器。
这篇文章提供了一个清晰的指南，帮助读者了解如何在Spring Boot应用程序中集成和使用Netty。它涵盖了从添加依赖项到配置服务器，创建处理器，处理异常和错误，以及处理并发请求的方方面面。对于那些希望在Spring Boot项目中使用Netty的开发人员来说，这篇文章是一个很好的参考资料。
源码下载
如果需要完整源码请关注公众号"架构殿堂" ，回复 "SpringBoot+Netty"即可获得
写在最后
感谢您的支持和鼓励！ 😊🙏
如果大家对相关文章感兴趣，可以关注公众号"架构殿堂"，会持续更新AIGC，系统架构, 分布式, java, GO, python, 游戏相关 等系列文章，一系列干货随时送达!文章来源：https://www.toymoban.com/news/detail-716762.html
文章来源地址https://www.toymoban.com/news/detail-716762.html
到了这里，关于SpringBoot整合Netty的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
