【Netty源码系列(一)】SpringBoot整合Netty实现多端口绑定

已于 2022-11-08 17:04:27 修改
阅读量4.2k 收藏 18
点赞数 3
分类专栏： 源码 Java学习 文章标签： spring boot java spring Netty
于 2022-11-08 17:01:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43407520/article/details/127750062
版权

文章目录

1 新建springboot项目引入jar包

本次采用jdk1.8、springboot2.7.5、Netty4.1.84.Final版本

	<dependency>
	    <groupId>org.springframework.boot</groupId>
	    <artifactId>spring-boot-starter-web</artifactId>
	</dependency>
	<!-- netty依赖 springboot2.x自动导入版本 -->
	<dependency>
	    <groupId>io.netty</groupId>
	    <artifactId>netty-all</artifactId>
	</dependency>

2 创建ServerBootstrap Netty服务端启动类

主要包括以下几步：

  1. 创建NioEventLoopGroup线程组
  2. 创建ServerBootstrap辅助启动类
  3. 设置group线程组
  4. 设置channel通道的类型
  5. 初始化通道，这一步可以设置连接类型，编解码信息及自定义请求处理器
  6. 绑定端口并启动
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

/**
 * @author lics
 * @version 1.0.0
 * @date 2022/10/31 15:14
 */
public class MyNettyServer {

    public void startNettyServer(int... ports) {

        /*
         * 配置服务端的NIO线程组
         * NioEventLoopGroup 是用来处理I/O操作的Reactor线程组
         * bossGroup：用来接收进来的连接，workerGroup：用来处理已经被接收的连接,进行socketChannel的网络读写，
         * bossGroup接收到连接后就会把连接信息注册到workerGroup
         * workerGroup的EventLoopGroup默认的线程数是CPU核数的二倍
         */
        EventLoopGroup bossGroup = new NioEventLoopGroup(2);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            // ServerBootstrap 是一个启动NIO服务的辅助启动类
            ServerBootstrap serverBootstrap = new ServerBootstrap();

            // 设置group，将bossGroup， workerGroup线程组传递到ServerBootstrap
            serverBootstrap = serverBootstrap.group(bossGroup, workerGroup);

            // ServerSocketChannel是以NIO的selector为基础进行实现的，用来接收新的连接，这里告诉Channel通过NioServerSocketChannel获取新的连接
            serverBootstrap = serverBootstrap.channel(NioServerSocketChannel.class);
            
           // 初始化通道，主要用于网络I/O事件，记录日志，编码、解码消息
            serverBootstrap = serverBootstrap.childHandler(new MyNettyChannelInitializer());

            // 绑定端口，同步等待成功
            ChannelFuture[] channelFutures;
            ChannelFuture futureTcp;
            if (ports.length > 0) {
                channelFutures = new ChannelFuture[ports.length];
                int i = 0;
                for (Integer port : ports) {
                    // 绑定端口，同步等待成功 绑定的服务器
                    futureTcp = serverBootstrap.bind(port).sync();
                    channelFutures[i++] = futureTcp;
                    futureTcp.addListener(future -> {
                        if (future.isSuccess()) {
                            System.out.println("netty server 启动成功!" + port);
                        } else {
                            System.out.println("netty server 启动失败!" + port);
                        }
                    });
                }
                for (ChannelFuture future : channelFutures) {
                    // 等待服务器监听端口关闭
                    future.channel().closeFuture().sync();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 退出，释放线程池资源
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

3 自定义channel初始化设置

继承ChannelInitializer<Channel>类，重写initChannel()方法

import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

/**
 * 通道初始化
 *
 * @author lics
 * @version 1.0.0
 * @date 2022/10/31 15:16
 */
public class MyNettyChannelInitializer extends ChannelInitializer<Channel> {

    @Override
    protected void initChannel(Channel channel) {
        /**
         * 处理TCP请求
         */
        // ChannelOutboundHandler，依照逆序执行
        channel.pipeline().addLast("encoder", new StringEncoder());
        // 属于ChannelInboundHandler，依照顺序执行
        channel.pipeline().addLast("decoder", new StringDecoder());
        // 自定义TCP请求的处理器
        channel.pipeline().addLast(new TcpRequestHandler());
        
        /**
         * 下面代码是处理HTTP请求，测试时请把上面的TCP请求设置注释掉
         */
        // HTTP协议解析，用于握手阶段；此处放开则会处理HTTP请求，TCP请求不会处理
        channel.pipeline().addLast(new HttpServerCodec());
        channel.pipeline().addLast(new HttpObjectAggregator(1024 * 1024 * 100));
        // 自定义解析HTTP请求处理器
        channel.pipeline().addLast(new HttpRequestHandler());
    }

}

4 自定义I/O数据读写处理类

TCP请求，创建TcpRequestHandler类，继承ChannelInboundHandlerAdapter，重写里面的方法，channelRead()方法读取客户端传入的数据

import java.net.InetSocketAddress;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import lombok.extern.slf4j.Slf4j;

/**
 * I/O数据读写处理类 TCP连接
 *
 * @author lics
 * @version 1.0.0
 * @date 2022/10/31 15:17
 */
@Slf4j
public class TcpRequestHandler extends ChannelInboundHandlerAdapter {

    /**
     * 从客户端收到新的数据时，这个方法会在收到消息时被调用
     *
     * @param ctx
     * @param msg
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        System.out.println("channelRead: " + msg.toString());
        //回应客户端
        ctx.write("I got it");
    }

    /**
     * 从客户端收到新的数据、读取完成时调用
     *
     * @param ctx
     */
    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) {
        System.out.println("channel Read Complete");
        ctx.flush();
    }

    /**
     * 当出现 Throwable 对象才会被调用，即当 Netty 由于 IO 错误或者处理器在处理事件时抛出的异常时
     *
     * @param ctx
     * @param cause
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        System.out.println("exceptionCaught");
        cause.printStackTrace();
        ctx.close();//抛出异常，断开与客户端的连接
    }

    /**
     * 客户端与服务端第一次建立连接时 执行
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        super.channelActive(ctx);
        ctx.channel().read();
        InetSocketAddress insocket = (InetSocketAddress) ctx.channel().remoteAddress();
        String clientIp = insocket.getAddress().getHostAddress();
        //此处不能使用ctx.close()，否则客户端始终无法与服务端建立连接
        System.out.println("channelActive: " + clientIp + ctx.name());
    }

    /**
     * 客户端与服务端 断连时 执行
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        super.channelInactive(ctx);
        InetSocketAddress insocket = (InetSocketAddress) ctx.channel().remoteAddress();
        String clientIp = insocket.getAddress().getHostAddress();
        ctx.close(); //断开连接时，必须关闭，否则造成资源浪费，并发量很大情况下可能造成宕机
        System.out.println("channelInactive: " + clientIp);
    }

    /**
     * 服务端当read超时, 会调用这个方法
     *
     * @param ctx
     * @param evt
     * @throws Exception
     */
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        super.userEventTriggered(ctx, evt);
        InetSocketAddress insocket = (InetSocketAddress) ctx.channel().remoteAddress();
        String clientIp = insocket.getAddress().getHostAddress();
        ctx.close();//超时时断开连接
        System.out.println("userEventTriggered: " + clientIp);
    }

    @Override
    public void channelRegistered(ChannelHandlerContext ctx) {
        System.out.println("channelRegistered");
    }

    @Override
    public void channelUnregistered(ChannelHandlerContext ctx) {
        System.out.println("channelUnregistered");
    }

    @Override
    public void channelWritabilityChanged(ChannelHandlerContext ctx) {
        System.out.println("channelWritabilityChanged");
    }

}

HTTP请求，创建HttpRequestHandler类，继承SimpleChannelInboundHandler<FullHttpRequest>，重写channelRead0()方法

import com.alibaba.fastjson.JSONObject;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.PooledByteBufAllocator;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.*;
import io.netty.handler.codec.http.multipart.Attribute;
import io.netty.handler.codec.http.multipart.HttpPostRequestDecoder;
import io.netty.handler.codec.http.multipart.InterfaceHttpData;

import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;

/**
 * HTTP连接请求处理
 *
 * @author lics
 * @version 1.0.0
 * @date 2022/11/2 11:03
 */
public class HttpRequestHandler extends SimpleChannelInboundHandler<FullHttpRequest> {

    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, FullHttpRequest fullHttpRequest) {

        String uri = fullHttpRequest.uri();
        System.out.println(uri);
        switch (fullHttpRequest.method().name()) {
            case "GET":
                processGetRequest(fullHttpRequest);
                break;
            case "POST":
                if (fullHttpRequest.headers().get("Content-Type").contains("x-www-form-urlencoded")) {
                    processPostFormRequest(fullHttpRequest);
                } else if (fullHttpRequest.headers().get("Content-Type").contains("application/json")) {
                    processPostJsonRequest(fullHttpRequest);
                }
                break;
            default:
        }
        ByteBuf buf = PooledByteBufAllocator.DEFAULT.buffer();
        buf.writeCharSequence("sucess", StandardCharsets.UTF_8);
        FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, buf);
        response.headers().set("Content-Type","application/json;charset=UTF-8");
        response.headers().set("Content-Length",response.content().readableBytes());

        channelHandlerContext.channel().writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    }

    /**
     * 处理get请求
     * @param request
     */
    private void processGetRequest(FullHttpRequest request){
        QueryStringDecoder decoder = new QueryStringDecoder(request.uri());
        Map<String, List<String>> params = decoder.parameters();
        params.forEach((key, value) -> System.out.println(key + " ==> "+ value));
    }

    /**
     * 处理post form请求
     * @param request
     */
    private void processPostFormRequest(FullHttpRequest request){
        HttpPostRequestDecoder decoder = new HttpPostRequestDecoder(request);
        List<InterfaceHttpData> httpDataList = decoder.getBodyHttpDatas();
        httpDataList.forEach(item -> {
            if (item.getHttpDataType() == InterfaceHttpData.HttpDataType.Attribute){
                Attribute attribute = (Attribute) item;
                try {
                    System.out.println(attribute.getName() + " ==> " + attribute.getValue());
                }catch (Exception e){
                    e.printStackTrace();
                }

            }
        });
    }

    /**
     * 处理post json请求
     * @param request
     */
    private void processPostJsonRequest(FullHttpRequest request){
        ByteBuf content = request.content();
        byte[] bytes = new byte[content.readableBytes()];
        content.readBytes(bytes);

        JSONObject jsonObject = JSONObject.parseObject(new String(bytes));
        jsonObject.getInnerMap().forEach((key,value) -> System.out.println(key + " ==> " + value));
    }
}

5 启动Netty服务端

import com.primeton.netty.server.MyNettyServer;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.EnableAsync;

/**
 * 启动类
 *
 * @author lics
 * @version 1.0.0
 * @date 2022/10/31 15:17
 */
@EnableAsync
@SpringBootApplication
public class NettyApplication implements CommandLineRunner {

    public static void main(String[] args) {
        SpringApplication app = new SpringApplication(NettyApplication.class);
        app.run(args);
    }

    @Async
    @Override
    public void run(String... args) {
        /*
         * 使用异步注解方式启动netty服务端服务
         */
        new MyNettyServer().startNettyServer(5678,8888);
    }

}

启动成功后，可以看到控制台会打印两行输出
在这里插入图片描述

5.1 TCP连接测试

使用客户端连接工具进行连接测试
输入端口号，地址，点击TCP连接测试

发送 ‘Hello world’ 数据，控制台打印并发送 ‘I got it’ 到客户端
发送数据后，结果如下

TCP/UDP连接工具下载
链接：https://pan.baidu.com/s/1YMg602U9xPgGVsFZx5zVaw
提取码：144t

5.2 HTTP连接测试

这里进行HTTP连接测试时，要把MyNettyChannelInitializer类中有关TCP连接的代码注掉，否则会连接失败

在这里插入图片描述
到此，spring boot整合Netty完成，后面将根据这个demo去跟踪学习Netty的源码，喜欢可以关注一下，大家一起学习，共同进步。

亭子下的李子
关注
专栏目录
spring-boot-protocol：springboot功能扩展-netty动态协议，可以支持各种网络协议的动态切换（单端口支持多个网络协议）。支持mmap，sendfile零拷贝，http请求批量聚合
01-30
用Netty实现的Spring-boot-protocol 将springboot的WebServer更改为NettyTcpServer，为用户扩展了网络编程的能力。 多协议服务器，Springboot协议扩展包，允许单端口提供多协议服务。其中内置多个网络传输（标准与规范）的实现库，轻松添加或扩展协议。例如：HttpServlet，RPC，MQTT（物联网通讯协议），Websocket，RTSP（流媒体协议），DNS（域名解析协议），MYSQL协议。 1.可以替代tomcat或jetty. 导包后一个@EnableNettyEmbedded注解即用. 2.支持http请求聚合, 然后用 select * from id in (httpRequestList). 示例：com.github.netty.http.example.HttpGroupByApiController.java 3.支持异步零拷贝。sendFile, mmap. 示例：com.github.netty.http.example.HttpZeroCopyController.java 4.HttpServlet
springboot整合netty（二）
weixin_34150503的博客
09-03 726
[TOC] 前言 上一篇讲了netty的一个入门的demo；项目上我也把数据处理做好了，就要开始存数据库了；我用的mybatis框架，如果单独使用还是觉得比较麻烦，所以就用了springboot+mybatis+netty；本篇主要讲netty与springboot的整合，以及我在这个过程中遇到的问题，又是怎么去解决的； 正文 我在做springboot与netty整合的时候在谷歌，百度找了无数文...
Spring Boot+Netty
mosrry的博客
09-11 1018
因工作中需要给第三方屏幕厂家下发广告，音频，图片等内容，使用Netty长链接进行数据传输。
Java采用Netty实现基于DTU的TCP服务器 + 多端口 + 多协议
05-18
JAVA采用Netty库实现基于以DTU传输的TCP服务器 ，可以支持多端口通讯 ，同时也支持 多协议解析
【实现netty服务同时监听多个端口，处理多套协议】
GBK_8的博客
07-14 7034
netty一个提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。 在上一篇文章中介绍了Netty怎么去实现和硬件双工通信：https://blog.csdn.net/GBK_8/article/details/123256716?spm=1001.2014.3001.5502 端口配置类 2. 通道初始化 3. 创建对应的解析器和编码器 3.1 信息解析器 3.2 信息编码器 4. 编写服务端处理器 5. Netty服务启动类 结尾 到此netty服务
Netty案例(三)之多端口
jannal专栏
02-28 7318
文章目录netty版本服务端多端口绑定客户端连接多个服务端端口 netty版本 netty版本:io.netty:netty-all:4.1.33.Final 服务端多端口绑定 服务端单进程多端口绑定,如果要停止某一个端口的监听，一定不能停止EventLoop和Accept线程，单独关闭某一个Channel即可。 package cn.jannal.netty; ...
netty 多端口多协议
qq_22185423的博客
12-17 2447
netty 多端口多协议
netty 多个端口_Netty实践（一）：轻松入门
weixin_39847099的博客
12-23 2364
作者：zfz_linux_boy原文：http://blog.51cto.com/zhangfengzhe/1890017前言Netty作为目前世界上最流行的NIO框架之一，在功能、性能、健壮性方面首屈一指，而且在很多项目中得到验证，比如消息中间件RocketMQ、分布式通信框架Dubbox。Netty内部实现复杂，但是提供给外界的API却十分简单，轻松的让我们的网络处理代码和业务逻辑处理代码分离...
Netty权威指南-Netty源码
09-30
然后通过绑定端口启动服务器，这会触发一系列的事件，如 BIND、CONNECT 和 ACCEPT。 接着，我们深入到 ChannelHandlerContext 和 ChannelInboundHandlerAdapter，这两个是处理网络事件的关键。...
Netty核心之Channel源码学习
01-20
在深入探讨Netty的Channel源码之前，先理解Channel的概念是非常重要的。Channel是Netty中的核心组件，它代表了一个打开的连接，可以用于读写数据。在这个Netty核心之Channel源码的学习过程中，我们将主要关注服务端...
Netty in action 第二版 源码
09-25
4. **Pipeline**: Pipeline是Netty中的一系列处理器链，每个处理器（Handler）负责处理特定类型的事件或数据。当数据通过Pipeline时，会依次经过这些处理器。 5. **EventLoop**: 事件循环是Netty异步模型的基础，它...
netty 多个端口_Netty 启动流程解析
weixin_39562340的博客
11-28 1697
Netty的启动流程(ServerBootstrap)，就是创建NioEventLoopGroup（内部可能包含多个NioEventLoop，每个eventLoop是一个线程，内部包含一个FIFO的taskQueue和Selector）和ServerBootstrap实例，并进行bind的过程（bind流程涉及到channel的创建和注册），之后就可以对外提供服务了。Netty的启动流程中，涉及到...
netty 多个 本地udp端口_Netty学习笔记
weixin_39789399的博客
12-03 349
各位骚年好,我又来了.上次写文章是啥时候? 忘了,也懒得翻记录,总之,很久没写知乎文章了其实吧,不是很愿意把这个所谓的碎碎念记下的一些笔记(很多还是从其他地方抄的,做了一些修改和补充)叫做所谓的“文章”.感觉是对这两个字的侮辱. 或许叫做学习笔记,可能更合适,不过先这么称呼吧,总比“震惊,26岁大叔居然对Netty做出这样的事情...”这类丧心病狂的标题好一些.回想自己年轻的时候,在那本科的青葱岁...
netty框架如何绑定多个端口，以下两种方式应该是哪一种？
信徒博客
10-10 5087
旨在发现思路漏洞，培养缜密思维。 以下有两个代码片段，哪一个才是正确的？ 第一种：手动开启线程 第二种：bootstrap启动类绑定多个 解惑：第二种，因为bossGroup是多路复用机制，一个线程可以接受多个客户端的连接的，如果是第一种的话，netty框架的优势何在！ 延伸：你觉得方案一需要为一个类开启线程么？ 不需要，开线程的目的是为了同步监听两个端口，现在netty框...
SpringBoot 整和 Netty 并监听多端口
帅气Dee海绵宝宝
10-16 1097
SpringBoot 整和 Netty 并监听多端口
Netty 服务监听多个端口
大鱼的博客
03-04 7867
本文记录使用 Netty 实现多个端口监听
netty学习（3）:SpringBoot整合netty实现多个客户端与服务器通信
weixin_42774617的博客
07-03 5965
整体工程目录：一个server服务（netty服务器），两个client服务（netty客户端）pom文件引入netty依赖，springboot依赖。创建一个SpringBoot工程，然后创建三个子模块。然后按照相同的方法创建client2。
springboot 使用netty-socketio共用springboot端口并有多个前缀请求地址
最新发布
09-19
在Spring Boot项目中，结合Netty-SocketIO库可以实现在同一个服务器端口上提供多个WebSocket连接，并为每个连接分配不同的请求前缀。Netty-SocketIO是一个基于Netty框架的实时通信库，常用于构建WebSocket应用。 首先，你需要在pom.xml文件中添加Netty-SocketIO依赖： ```xml <dependency> <groupId>com.corundumstudio.socketio</groupId> <artifactId>netty-socketio</artifactId> <version>1.7.40</version> </dependency> ``` 然后，在Spring Boot配置类中启用WebSocket支持，并创建SocketIOServer实例： ```java import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.socket.config.annotation.EnableWebSockets; import io.socket.io.Server; @Configuration @EnableWebSockets public class SocketIOConfig { @Bean public Server socketIoServer() { return new Server("localhost", port, "/socket1"); // 假设第一个前缀是/socket1 } // 如果需要第二个前缀，可以再加一个bean，比如"/socket2" } ``` 这里，`"localhost"`是你希望监听的IP地址，`port`是Spring Boot应用的端口号，`"/socket1"`则是第一个WebSocket的路径前缀。你可以根据需求增加更多的`Server` bean实例，对应不同的前缀。 客户端通过指定不同的URL访问，例如： - `ws://localhost:8080/socket1` - `ws://localhost:8080/socket2` 当客户端发起连接时，Netty-SocketIO会根据请求的URL前缀找到相应的`Server`实例处理连接。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值