深入解析Jedis jsonGet方法中字节数组值以.0结尾的问题及解决方案

import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.UnifiedJedis;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class JedisJsonByteConverter {

    public static void main(String[] args) {
        HostAndPort config = new HostAndPort("localhost", 6379);
        UnifiedJedis client = new UnifiedJedis(config);

        String key = "StandaloneResponse:9b970b5f-32c2-4265-92cb-9af9d6707782";
        Object rawObject = client.jsonGet(key);

        if (rawObject instanceof LinkedHashMap) {
            LinkedHashMap<String, Object> resultMap = (LinkedHashMap<String, Object>) rawObject;
            // 假设我们知道ReturnValue在variables下
            if (resultMap.containsKey("variables") && resultMap.get("variables") instanceof LinkedHashMap) {
                LinkedHashMap<String, Object> variables = (LinkedHashMap<String, Object>) resultMap.get("variables");
                if (variables.containsKey("ReturnValue") && variables.get("ReturnValue") instanceof List) {
                    List<?> rawReturnValue = (List<?>) variables.get("ReturnValue");
                    List<Byte> byteList = new ArrayList<>();
                    for (Object item : rawReturnValue) {
                        if (item instanceof Double) {
                            byteList.add(((Double) item).byteValue());
                        } else {
                            // 处理非Double类型，或者抛出异常
                            System.err.println("Unexpected type in ReturnValue: " + item.getClass().getName());
                        }
                    }
                    System.out.println("Converted ReturnValue as bytes: " + byteList);
                    // 替换原始map中的ReturnValue
                    variables.put("ReturnValue", byteList);
                }
            }
            System.out.println("Processed Object: " + resultMap);
        } else {
            System.out.println("Raw object is not a LinkedHashMap: " + rawObject);
        }
        client.close();
    }
}

import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.UnifiedJedis;
import redis.clients.jedis.json.Path;

public class JedisJsonGetByteArray {

    public static void main(String[] args) {
        HostAndPort config = new HostAndPort("localhost", 6379);
        UnifiedJedis client = new UnifiedJedis(config);

        String key = "StandaloneResponse:9b970b5f-32c2-4265-92cb-9af9d6707782";

        // 假设ReturnValue在顶层对象的variables字段下
        // 路径应根据实际JSON结构调整。例如，如果ReturnValue直接在根，路径为Path.ROOT
        // 根据提供的问题输出，ReturnValue在 `variables` 字段下
        Path returnValuePath = Path.of(".variables.ReturnValue"); 

        try {
            Byte[] returnValue = client.jsonGet(key, Byte[].class, returnValuePath);
            if (returnValue != null) {
                System.out.print("Retrieved ReturnValue as Byte array: [");
                for (int i = 0; i < returnValue.length; i++) {
                    System.out.print(returnValue[i]);
                    if (i < returnValue.length - 1) {
                        System.out.print(", ");
                    }
                }
                System.out.println("]");
            } else {
                System.out.println("ReturnValue not found or could not be converted.");
            }
        } catch (Exception e) {
            System.err.println("Error retrieving ReturnValue as Byte array: " + e.getMessage());
            e.printStackTrace();
        } finally {
            client.close();
        }
    }
}

import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.UnifiedJedis;
import redis.clients.jedis.json.JsonProtocol;
import redis.clients.jedis.args.CommandArguments;
import redis.clients.jedis.util.SafeEncoder;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class JedisRawCommandGet {

    public static void main(String[] args) {
        HostAndPort config = new HostAndPort("localhost", 6379);
        UnifiedJedis client = new UnifiedJedis(config);

        String key = "StandaloneResponse:9b970b5f-32c2-4265-92cb-9af9d6707782";

        try {
            // 执行原始JSON GET命令，获取整个JSON字符串
            // 注意：JsonProtocol.JsonCommand.GET 默认是获取整个JSON文档
            // 如果需要特定路径，可能需要构造更复杂的命令，例如 JSON.GET <key> .variables.ReturnValue
            // Jedis 4.x 的 executeCommand 接受 CommandArguments
            // 这里我们先获取整个JSON，然后手动解析
            CommandArguments args = new CommandArguments(JsonProtocol.JsonCommand.GET).add(key);
            Object rawResponse = client.executeCommand(args);

            if (rawResponse instanceof byte[]) {
                String jsonString = SafeEncoder.encode((byte[]) rawResponse);
                System.out.println("Raw JSON string from executeCommand: " + jsonString);

                // 假设我们知道ReturnValue是一个数字列表，并且格式是 [val1, val2, ...]
                // 这里需要更复杂的JSON解析逻辑，可以使用Jackson, Gson等库
                // 简单示例：从字符串中提取数字列表
                Pattern pattern = Pattern.compile("ReturnValue=\[([\d.,\s]+)\]");
                Matcher matcher = pattern.matcher(jsonString);

                if (matcher.find()) {
                    String numbersStr = matcher.group(1);
                    String[] numberTokens = numbersStr.split(",\s*");
                    List<Byte> byteList = new ArrayList<>();
                    for (String token : numberTokens) {
                        try {
                            // 移除 .0 后缀，并转换为 byte
                            byteList.add((byte) Double.parseDouble(token)); 
                        } catch (NumberFormatException e) {
                            System.err.println("Could not parse number token: " + token);
                        }
                    }
                    System.out.println("Parsed ReturnValue as bytes: " + byteList);
                } else {
                    System.out.println("ReturnValue not found in raw JSON string.");
                }

            } else {
                System.out.println("Raw response is not a byte array: " + rawResponse);
            }
        } catch (Exception e) {
            System.err.println("Error executing raw command: " + e.getMessage());
            e.printStackTrace();
        } finally {
            client.close();
        }
    }
}