webflux 解析modbus数据并封装为地址、寄存器数据、数据bean，其中数据转化成float形式

要解析Modbus数据并封装为地址、寄存器数据、数据bean，可以使用`reactor-netty`的`TcpClient`来进行数据的读取和处理。下面是一个示例代码实现：

public class ModbusClient {
    private final Logger logger = LoggerFactory.getLogger(ModbusClient.class);

    private final String host;
    private final int port;

    public ModbusClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public Flux<ModbusData> readModbusData(int address, int register, int count) {
        return TcpClient.create()
                .host(host)
                .port(port)
                .handle((in, out) -> {
                    ByteBuf request = Unpooled.buffer(12);
                    request.writeShort(0); // transaction identifier
                    request.writeShort(0); // protocol identifier
                    request.writeShort(6); // length
                    request.writeByte(1); // unit identifier
                    request.writeByte(3); // function code
                    request.writeShort(address); // starting address
                    request.writeShort(register); // register count
                    out.send(Mono.just(request));

                    return in.receive()
                            .flatMap(response -> {
                                if (response.readableBytes() < 9) {
                                    return Mono.error(new ModbusException("Invalid response length: " + response.readableBytes()));
                                }

                                int transactionId = response.readShort();
                                int protocolId = response.readShort();
                                int length = response.readShort();
                                int unitId = response.readByte();
                                int functionCode = response.readByte();

                                if (functionCode != 3) {
                                    return Mono.error(new ModbusException("Invalid function code: " + functionCode));
                                }

                                if (response.readableBytes() < count * 2) {
                                    return Mono.error(new ModbusException("Invalid response length: " + response.readableBytes()));
                                }

                                List<Float> data = new ArrayList<>(count);
                                for (int i = 0; i < count; i++) {
                                    int value = response.readShort();
                                    data.add(Float.intBitsToFloat(value));
                                }

                                return Mono.just(new ModbusData(address, register, data));
                            });
                })
                .retryBackoff(3, Duration.ofSeconds(1))
                .doOnError(ex -> logger.error("Modbus read error: {}", ex.getMessage()))
                .flux();
    }
}

在这个示例代码中，我们使用`TcpClient`来建立与Modbus设备的连接，并发送读取指定地址、寄存器、数据长度的数据请求。在接收到响应后，我们解析响应数据，将每个寄存器的值转换为float类型，并封装为一个`ModbusData`对象。最后，我们将读取到的数据作为`Flux`返回。

可以在Controller层使用该类来实现对Modbus数据的读取和处理，例如：

@RestController
public class ModbusController {
    private final ModbusClient modbusClient;

    public ModbusController(ModbusClient modbusClient) {
        this.modbusClient = modbusClient;
    }

    @GetMapping("/modbus/{address}/{register}/{count}")
    public Flux<ModbusData> readModbusData(@PathVariable int address, @PathVariable int register, @PathVariable int count) {
        return modbusClient.readModbusData(address, register, count);
    }
}

在这个示例中，我们使用`@GetMapping`注解来定义了一个`/modbus/{address}/{register}/{count}`的API接口，用于读取Modbus设备的指定地址、寄存器、数据长度的数据。调用`ModbusClient`的`readModbusData`方法来实现数据的读取和处理。