<dependency>
     <groupId>io.netty</groupId>
     <artifactId>netty-all</artifactId>
     <version>4.1.28.Final</version>
</dependency>

//netty:
//  port: {8300: A, 8500: B}
@Data
@Configuration
@ConfigurationProperties(prefix = "netty")
public class PortDefinition {

    Map<Integer, String> port;
}

public class GatewayType {
    //個人設備
    public final static String GERNESHEBEI_SHOUHUA="A";
}

@Slf4j
@RefreshScope
@Component
public class NettyServer {
    @Autowired
    private PortDefinition portDefinition;
    public void start() throws InterruptedException {
        /**
         * 創(chuàng)建兩個線程組 bossGroup 和 workerGroup
         * bossGroup 只是處理連接請求，真正的和客戶端業(yè)務處理，會交給 workerGroup 完成
         *  兩個都是無線循環(huán)
         */
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            //創(chuàng)建服務器端的啟動對象，配置參數(shù)
            ServerBootstrap bootstrap = new ServerBootstrap();
            //設置兩個線程組
            bootstrap.group(bossGroup, workerGroup)
                    //使用NioServerSocketChannel 作為服務器的通道實現(xiàn)
                    .channel(NioServerSocketChannel.class)
                    //設置線程隊列得到連接個數(shù)
                    .option(ChannelOption.SO_BACKLOG, 128)
                    //設置保持活動連接狀態(tài)
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    //通過NoDelay禁用Nagle,使消息立即發(fā)出去，不用等待到一定的數(shù)據(jù)量才發(fā)出去
                    .childOption(ChannelOption.TCP_NODELAY, true)
                    //可以給 bossGroup 加個日志處理器
                    .handler(new LoggingHandler(LogLevel.INFO))
					//監(jiān)聽多個端口
                    .childHandler(new SocketChannelInitHandler(portDefinition.getPort()))
            ;
//            監(jiān)聽多個端口
            Map<Integer, String> ports = portDefinition.getPort();
            log.info("netty服務器在{}端口啟動監(jiān)聽", JSONObject.toJSONString(ports));
            for (Map.Entry<Integer, String> p : ports.entrySet()) {
                final int port = p.getKey();
                // 綁定端口
                ChannelFuture cf = bootstrap.bind(new InetSocketAddress(port)).sync();
                if (cf.isSuccess()) {
                    log.info("netty 啟動成功，端口：{}", port);
                } else {
                    log.info("netty 啟動失敗，端口：{}", port);
                }
                //對關閉通道進行監(jiān)聽
                cf.channel().closeFuture().sync();
            }
        } finally {
            //發(fā)送異常關閉
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

@Slf4j
public class SocketChannelInitHandler extends ChannelInitializer<SocketChannel> {
    /**
     * 用來存儲每個連接上來的設備
     */
    public static final Map<ChannelId, ChannelPipeline> CHANNEL_MAP = new ConcurrentHashMap<>();
    /**
     * 端口信息，用來區(qū)分這個端口屬于哪種類型的連接 如：8300 屬于 A
     */
    Map<Integer, String> ports;
    public SocketChannelInitHandler(Map<Integer, String> ports) {
        this.ports = ports;
    }
    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        //每次連接上來 對通道進行保存
        CHANNEL_MAP.put(socketChannel.id(), socketChannel.pipeline());
        ChannelPipeline pipeline = socketChannel.pipeline();
        int port = socketChannel.localAddress().getPort();
        String type = ports.get(port);
        pipeline.addLast(new StringEncoder(StandardCharsets.UTF_8));
        pipeline.addLast(new StringDecoder(StandardCharsets.UTF_8));
        pipeline.addLast(new LengthFieldBasedFrameDecoder(24*1024,0,2));
        log.info("【initChannel】端口號： "+port+"  類型： "+type);
        //不同類型連接，處理鏈中加入不同處理協(xié)議
        switch (type) {
            case GatewayType.GERNESHEBEI_SHOUHUA:
                //手環(huán)
                pipeline.addLast(new NettyServerHandler());
                break;
            default:
                log.error("當前網(wǎng)關類型并不存在于配置文件中，無法初始化通道");
                break;
        }
    }
}

@Slf4j
public class NettyServerHandler extends SimpleChannelInboundHandler<Object> {
    //private static final Logger log = LoggerFactory.getLogger(NettyServerHandler.class);
    protected void channelRead0(ChannelHandlerContext context, Object obj) throws Exception {
        log.info(">>>>>>>>>>>服務端接收到客戶端的消息：{}",obj);
        String message = (String)obj;
		//之后寫自己的業(yè)務邏輯即可
        String b=message.replace("[", "")
                .replace("]","");
        String[] split1 = b.split("\\*");
        String key = split1[1];
        SocketChannel socketChannel = (SocketChannel) context.channel();
		//調用業(yè)務代碼類并執(zhí)行
        WristWatchSocket.runSocket(key,message,socketChannel,true);
        ReferenceCountUtil.release(obj);
    }
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.close();
    }
}

@Slf4j
//@Data
public class WristWatchSocket{
    //業(yè)務代碼
    public static void runSocket(String key, String message, SocketChannel socketChannel, Boolean isNotFirst){
        try {
            if(message==null||message.trim().equals("")){
                return;
            }
            String restr="測試發(fā)送";
            if(!"".equals(restr)){
                socketChannel.writeAndFlush(restr);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

netty:
  port: {8300: A, 8500: B}

@EnableAsync
@EnableSwagger2
@EnableFeignClients
@EnableTransactionManagement
@Slf4j
@MapperScan({"com.yuandian.platform.mapper"})
@SpringBootApplication(exclude={DataSourceAutoConfiguration.class})
public class YunYiplatformApplication {
    public static void main(String[] args) {
        ApplicationContext run = SpringApplication.run(YunYiplatformApplication.class, args);
        log.info("\n\n【【【【平臺成功啟動！】】】】\n");
        //netty 啟動配置
        try {
            run.getBean(NettyServer.class).start();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}