springboot使用NettyServer实现非阻塞socket的完整源码

以下是使用Spring Boot和Netty实现非阻塞socket的完整源码。这个例子会创建一个简单的Echo服务器，它会接收客户端发送的消息并将其返回给客户端。

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.stereotype.Component;

@SpringBootApplication
public class NettyServerApplication {

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

    @Component
    public static class NettyServer {

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

        public void start() throws Exception {
            EventLoopGroup bossGroup = new NioEventLoopGroup(1);
            EventLoopGroup workerGroup = new NioEventLoopGroup();

            try {
                ServerBootstrap b = new ServerBootstrap();
                b.group(bossGroup, workerGroup)
                        .channel(NioServerSocketChannel.class)
                        .childHandler(new ChannelInitializer<SocketChannel>() {
                            @Override
                            public void initChannel(SocketChannel ch) throws Exception {
                                ch.pipeline().addLast(new EchoServerHandler());
                            }
                        })
                        .option(ChannelOption.SO_BACKLOG, 128)
                        .childOption(ChannelOption.SO_KEEPALIVE, true);

                ChannelFuture f = b.bind(port).sync();

                f.channel().closeFuture().sync();
            } finally {
                workerGroup.shutdownGracefully();
                bossGroup.shutdownGracefully();
            }
        }
    }

    public static class EchoServerHandler extends ChannelInboundHandlerAdapter {
        @Override
        public void channelRead(ChannelHandlerContext ctx, Object msg) {
            ctx.write(msg);
        }

        @Override
        public void channelReadComplete(ChannelHandlerContext ctx) {
            ctx.flush();
        }

        @Override
        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
            cause.printStackTrace();
            ctx.close();
        }
    }
}

在这个例子中，我们创建了一个`NettyServer`组件，它会在Spring应用程序启动时自动启动。`NettyServer`类中的`start()`方法会创建一个Netty服务器，并将其绑定到指定的端口。

在`ServerBootstrap`构造函数中，我们设置了事件循环组（boss和worker），服务器通道类型（NioServerSocketChannel），并设置了一个`ChannelInitializer`，它会在每个新连接被接受时创建一个新的`EchoServerHandler`实例。

`EchoServerHandler`类是我们的Echo服务器的核心部分。它会在收到客户端发送的消息时将其返回给客户端。`channelRead()`方法会被自动调用，当有新的消息被接收到时。在`channelReadComplete()`方法中，我们调用了`ctx.flush()`，它会将所有待发送的消息一次性发送到远程节点。在`exceptionCaught()`方法中，我们打印出异常信息并关闭连接。

最后，我们在`application.properties`文件中设置了服务器端口号：

netty.port=8888

使用此代码，您可以创建一个简单的Echo服务器，并使用Netty在Spring Boot应用程序中执行非阻塞socket通信。