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

        <!-- Обработка Json -->
        <dependency>
            <groupId>com.alibaba.fastjson2</groupId>
            <artifactId>fastjson2</artifactId>
            <version>2.0.16</version>
        </dependency>

# netty Конфигурация
netty:
  # Количество потоков босса
  boss: 4
  # Количество рабочих потоков
  worker: 2
  # тайм-аут
  timeout: 6000
  # Основной порт сервера
  port: 18023
  # Резервный порт сервера
  portSalve: 18026
  # Адрес сервера
  host: 127.0.0.1

@Configuration
@ConfigurationProperties(prefix = "netty")
public class NettyProperties {

    /**
     * Количество потоков босса
     */
    private Integer boss;

    /**
     * Количество рабочих потоков
     */
    private Integer worker;

    /**
     * тайм-аут
     */
    private Integer timeout = 30000;

    /**
     * Основной порт сервера
     */
    private Integer port = 18023;

    /**
     * Резервный порт сервера
     */
    private Integer portSalve = 18026;

    /**
     * Адрес сервера По умолчанию локально
     */
    private String host = "127.0.0.1";
	
	// setter、getter 。。。。
}

@Configuration
@EnableConfigurationProperties
public class NettyConfig {
    final NettyProperties nettyProperties;

    public NettyConfig(NettyProperties nettyProperties) {
        this.nettyProperties = nettyProperties;
    }

    /**
     * пул потоков босса - для подключения клиента
     *
     * @return
     */
    @Bean
    public NioEventLoopGroup boosGroup() {
        return new NioEventLoopGroup(nettyProperties.getBoss());
    }

    /**
     * Пул рабочих потоков — для бизнес-обработки
     *
     * @return
     */
    @Bean
    public NioEventLoopGroup workerGroup() {
        return new NioEventLoopGroup(nettyProperties.getWorker());
    }

    /**
     * Лаунчер сервера, прослушивание подключения клиента
     *
     * @return
     */
    @Bean
    public ServerBootstrap serverBootstrap() {
        ServerBootstrap serverBootstrap = new ServerBootstrap()
                // Укажите группу потоков для использования
                .group(boosGroup(), workerGroup())
                // Укажите канал для использования
                .channel(NioServerSocketChannel.class)
                // обозначениетайм-аут
                .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, nettyProperties.getTimeout())
                // Укажите рабочий процессор
                .childHandler(new NettyServerHandler());
        return serverBootstrap;
    }
}

public class NettyServerHandler extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel socketChannel) throws Exception {
        // данныесепаратор        String delimiterStr = "##@##";
        ByteBuf delimiter = Unpooled.copiedBuffer(delimiterStr.getBytes());
        ChannelPipeline pipeline = socketChannel.pipeline();
        // Используйте специальную обработку распаковки/погружения и максимальную длину 1024 байта на поиск.
        pipeline.addLast(new DelimiterBasedFrameDecoder(1024, delimiter));
        // Перекодируйте данные, декодированные на предыдущем шаге, в экземпляр сообщения.
        pipeline.addLast(new MessageDecodeHandler());
        // Закодируйте данные отправляющего клиента и добавьте разделитель данных.
        pipeline.addLast(new MessageEncodeHandler(delimiterStr));
        // Окончательная обработка данных
        pipeline.addLast(new ServerListenerHandler());
    }
}

public class MessageDecodeHandler extends ByteToMessageDecoder {

    @Override
    protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf in, List<Object> list) throws Exception {
        ByteBuf frame = in.retainedDuplicate();
        final String content = frame.toString(CharsetUtil.UTF_8);
        Message message = new Message(content);
        list.add(message);
        in.skipBytes(in.readableBytes());
    }
}

public class Message {
    /**
     * данныедлина     */
    private Integer len;

    /**
     * Информационные бюллетени, полученные databody
     */
    private String content;

    /**
     * Тип сообщения
     */
    private Integer msgType;

    public Message(Object object) {
        String str = object.toString();
        JSONObject jsonObject = JSONObject.parseObject(str);
        msgType = Integer.valueOf(jsonObject.getString("msg_type"));
        content = jsonObject.getString("body");
        len = str.length();
    }

    public String toJsonString() {
        return "{" +
                "\"msg_type\": " + msgType + ",\n" +
                "\"body\": " + content +
                "}";
    }
	// setter、getter 。。。。
}

public class MessageEncodeHandler extends MessageToByteEncoder<Message> {
    // данныесепаратор    String delimiter;

    public MessageEncodeHandler(String delimiter) {
        this.delimiter = delimiter;
    }

    @Override
    protected void encode(ChannelHandlerContext channelHandlerContext, Message message, ByteBuf out) throws Exception {
        out.writeBytes((message.toJsonString() + delimiter).getBytes(CharsetUtil.UTF_8));
    }
}

public class ServerListenerHandler extends SimpleChannelInboundHandler<Message> {
    private static final Logger log = LoggerFactory.getLogger(ServerListenerHandler.class);

    /**
     * Обрабатывается, когда устройство подключено к сети
     *
     * @param ctx
     */
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) {
        log.info("Появились новые соединения: [{}]",ctx.channel().id().asLongText());
    }

    /**
     * данные не указаны
     *
     * @param ctx
     * @param сообщение
     */
    @Override
    защищенный недействительный каналRead0 (ChannelHandlerContext ctx, Message msg) {
        // Получить тело сообщения в экземпляре сообщения
        String content = msg.getContent();
        // к другому типу сообщения для обработки
        MessageEnum type = MessageEnum.getStructureEnum(msg);
        switch (type) {
            case CONNECT:
                // TODO Обработка сообщений Heartbeat
            case STATE:
                // TODO Статус устройства
            default:
                System.out.println(type.content + «Содержимое сообщения» + content);
        }
    }

    /**
     * Автономная обработка оборудования
     *
     * @param ctx
     */
    @Override
    public void handlerRemoved(ChannelHandlerContext ctx) {
        log.info("Устройство не в сети: {}", ctx.channel().id().asLongText());
    }

    /**
     * Устройство поддерживает обработку исключений
     *
     * @param ctx
     * @param cause
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        // Исключение печати
        log.info("Исключение: {}", cause.getMessage());
        // закрытиесоединять        ctx.close();
    }
}

public enum MessageEnum {
    CONNECT(1, «Сердцевое сообщение»),
    STATE(2, "Статус устройства");

    public final Integer type;
    public final String content;

    MessageEnum(Integer type, String content) {
        this.type = type;
        this.content = content;
    }

    // Используйте суждение в случае
    public static MessageEnum getStructureEnum(Message msg) {
        Integer type = Optional.ofNullable(msg)
                .map(Message::getMsgType)
                .orElse(0);
        if (type == 0) {
            return null;
        } else {
            List<MessageEnum> objectEnums = Arrays.stream(MessageEnum.values())
                    .filter((item) -> item.getType() == type)
                    .distinct()
                    .collect(Collectors.toList());
            if (objectEnums.size() > 0) {
                return objectEnums.get(0);
            }
            return null;
        }
    }
	// setter、getter。。。。
}

@Component
public class NettyServerBoot {
    private static final Logger log = LoggerFactory.getLogger(NettyServerBoot.class);
    @Resource
    NioEventLoopGroup boosGroup;
    @Resource
    NioEventLoopGroup workerGroup;
    final ServerBootstrap serverBootstrap;
    final NettyProperties nettyProperties;

    public NettyServerBoot(ServerBootstrap serverBootstrap, NettyProperties nettyProperties) {
        this.serverBootstrap = serverBootstrap;
        this.nettyProperties = nettyProperties;
    }


    /**
     * Запустить нетти
     *
     * @throws InterruptedException
     */
    @PostConstruct
    public void start() throws InterruptedException {
        // Привязать начало порта
        serverBootstrap.bind(nettyProperties.getPort()).sync();
        // Альтернативный порт
        serverBootstrap.bind(nettyProperties.getPortSalve()).sync();
        log.info("Запустите Netty: {},{}", nettyProperties.getPort(), nettyProperties.getPortSalve());
    }

    /**
     * Закрыть нетти
     */
    @PreDestroy
    public void close() {
        log.info("Закрыть Netty");
        boosGroup.shutdownGracefully();
        workerGroup.shutdownGracefully();
    }
}