springboot整合netty的正确姿势

近期做一些物联网方面项目，使用到了tcp协议，之前公司做过socket短连接，网上找了一个简单的demo，很早便学习到nio方面知识，学习了《netty从入门到精通》这本书，同时也根据网上视频做了几个demo，但学习不太深入，刚好物联网项目，就直接使用netty，前期直接使用这个框架，但作为近十年开发的java程序员，没有spring感觉总少了很多不便，后期改框架时想到了使用springboot整合netty代码。

先说之前项目中做socket代码怎么用spring管理的：利用springboot启动后启动socket服务，是没有被spring管理的

public class CouponApplication {

    public static void main(String[] args) {
        log.info("当前版本为：couponmisserver-0.0.5-SNAPSHOT");
        log.info("版本日期：2020-1-7");
        ApplicationContext context = SpringApplication.run(CouponApplication.class, args);
        //启动stock服务
        Integer port = Integer.valueOf(Config.getConfig().get("socketPort"));
        SocketServer socketServer = new SocketServer();
        socketServer.init(port, context);
    }

}

网上一大神推荐的一个使用`CommandLineRunner `来加一个线程启动netty

/**
 * author: hejz
 * data:  2022-5-9
 */
@SpringBootApplication
@Slf4j
@EnableScheduling
public class Application implements CommandLineRunner {
    @Autowired
    private NettyServer nettyServer;

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        nettyServer.serverRun();
    }

}

我目前也是这样做的，这样netty就被整合到springboot中去了，但是近期chatGPT非常火，晚上无聊时我也拿它来玩时问到它这个问题，看这个大神怎么回答的：

Spring Boot 中可以通过创建自定义的 NettyServer 或 NettyClient 类，并在其中实现 Netty 的服务端或客户端代码，然后在 Spring Boot 的应用程序中将其作为一个 Bean 注入到 Spring 容器中。以下是一个简单的示例代码，演示了如何整合 Netty 到 Spring Boot 应用程序中。

首先，创建一个自定义的 NettyServer 类，用于实现 Netty 的服务端代码：

@Component
public class NettyServer {

    @Value("${netty.server.port}")
    private int port;

    @PostConstruct
    public void start() throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast(new StringDecoder());
                            pipeline.addLast(new StringEncoder());
                            pipeline.addLast(new NettyServerHandler());
                        }
                    });

            ChannelFuture channelFuture = serverBootstrap.bind(port).sync();
            channelFuture.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

}

之前网上那个大神给我的建议，我在操作过程中junit测试时总要先把启动netty那个给注释掉，无疑chatGPT大神给我找到了另一种解决方案，而且比我用的要好的多，我直接使用其给的方案重新优化了代码。

一、启动类不要动，还是原来的springboot启动类，在 NettyServer上使用@Component注解让spring扫瞄管理，使用@PostConstruct注解直接运行netty服务

@Component
@Slf4j
public class NettyServer {
    @Autowired
    private NettyServerInitializer nettyServerInitializer;
    @Value("${nettyPort}")
    private Integer nettyPort;
    @PostConstruct
    public void serverRun() {
        //循环组接收连接，不进行处理,转交给下面的线程组
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        //循环组处理连接，获取参数，进行工作处理
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            //服务端进行启动类
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            //使用NIO模式，初始化器等等
            serverBootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(nettyServerInitializer);
            //绑定端口
            ChannelFuture channelFuture = serverBootstrap.bind(nettyPort).sync();
            log.info("tcp服务器已经启动…………");
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

二、添加NettyServerInitializer类加上@Component注解让spring扫瞄管理，使用@Autowired进行依赖注入管理

@Component
public class NettyServerInitializer extends ChannelInitializer<SocketChannel> {
    Logger log = LogManager.getLogger(NettyServerInitializer.class);
    @Autowired
    private NettyHandler nettyHandler;

    //连接注册，创建成功，会被调用
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        log.info("==================netty报告==================");
        log.info("信息：有一客户端链接到本服务端");
        log.info("IP:{}", ch.remoteAddress().getAddress());
        log.info("Port:{}", ch.remoteAddress().getPort());
        log.info("通道id:{}", ch.id().toString());
        log.info("==================netty报告完毕==================");
        ChannelPipeline pipeline = ch.pipeline();
        //定义读写空闲时间——（单位秒）
        pipeline.addLast(new IdleStateHandler(180, 60,180));
        //注册拦截器
        pipeline.addLast(nettyHandler);
    }
}

三、其它NettyServerHandler类加上@Component注解让spring扫瞄管理，使用@Autowired进行依赖注入管理,但注意需要添加@ChannelHandler.Sharable注解，防止程序报错

/**
 * @author:hejz 75412985@qq.com
 * @create: 2023-01-24 22:51
 * @Description: 注册拦截器——每个设备都需要注册
 */
@Component
@ChannelHandler.Sharable
@Slf4j
public class NettyHandler extends SimpleChannelInboundHandler<ByteBuf> {
    @Autowired
    private DtuRegister dtuRegister;   

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) throws Exception {
       //读到的客户端信息的逻辑处理（略）
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.getCause();
        NettyServiceCommon.deleteKey(ctx.channel());
        ctx.channel().close();
    }
}

至此，springboot整合netty完美解决，这才是便于理解和操作的方式，感谢网上使用监听器启动netty服务的那位大神，也感谢chatGPT大神给我提供另一种好的思路和方法