SpringBoot整合Netty_springboot netty

简介

Netty是一个基于Java的开源网络应用框架，它提供了高性能、异步事件驱动的网络编程能力。Netty旨在帮助开发者构建高性能、高可靠性的网络应用程序。

Netty提供了简洁的API和丰富的功能，可以轻松处理各种网络通信协议，如TCP、UDP、WebSocket等。它的设计理念是基于事件驱动和回调机制，而不是传统的线程模型，这使得它可以实现高并发、低延迟的网络通信。

通过使用Netty，开发者可以方便地处理复杂的网络通信逻辑，例如请求-响应模式、长连接、心跳检测等。Netty提供了灵活的编解码器和处理器，可以对网络数据进行高效的编解码和处理。同时，Netty还提供了可靠的错误处理机制和事件机制，方便开发者进行异常处理和扩展。

---

Netty特点

1. 高性能

   Netty采用了基于事件驱动的异步模型，通过使用非阻塞I/O操作和多线程处理请求，实现了高性能的网络通信。

2. 高可靠性

   Netty提供了一套强大的错误处理机制，包括异常处理、断线重连、心跳检测等，可以有效地处理网络中的各种异常情况，提高应用程序的可靠性。

3. 高可扩展性

   Netty的设计模式和组件化架构使得它非常易于扩展和定制。开发人员可以根据自己的需求，选择合适的组件和模块，构建出符合自己业务需求的网络应用程序。

4. 支持多种协议

   Netty支持多种常用的网络协议，包括HTTP、WebSocket、TCP、UDP等，可以满足不同场景下的网络通信需求。

实例

版本依赖

引入依赖

<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>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

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();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

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();
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

测试

先启动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
1
2
3
4
5
6
7
8
9
10

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();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

测试Http

访问链接：http://127.0.0.1:8089

hello netty http coding
1

总结

本文介绍了Spring Boot和Netty的基本概念和特点。然后，它详细解释了如何在Spring Boot项目中添加Netty依赖项，并配置Netty服务器。接下来，文章介绍了如何创建一个简单的Netty处理器，用于处理传入的网络请求。然后，它展示了如何在Spring Boot应用程序中使用这个Netty处理器。

这篇文章提供了一个清晰的指南，帮助读者了解如何在Spring Boot应用程序中集成和使用Netty。它涵盖了从添加依赖项到配置服务器，创建处理器，处理异常和错误，以及处理并发请求的方方面面。对于那些希望在Spring Boot项目中使用Netty的开发人员来说，这篇文章是一个很好的参考资料。

---

源码下载

​如果需要完整源码请关注公众号"架构殿堂" ，回复 "SpringBoot+Netty"即可获得

---

写在最后

感谢您的支持和鼓励！