深入理解Jedis jsonGet 方法对字节数组的处理及解决方案-java教程-PHP中文网

深入理解Jedis jsonGet 方法对字节数组的处理及解决方案

在使用 jedis 4.2.3 客户端通过 `unifiedjedis.jsonget()` 方法获取存储在 redis 中的 json 数据时，如果 json 字段中包含表示字节数组的数值列表，jedis 内部的 json 解析库（如 gson 或 `org.json:json`）可能会将这些数值自动向上转型为 `double` 类型，导致输出结果带有 `.0` 后缀。本文将详细探讨这一现象的原因，并提供三种有效的解决方案，包括数据后处理、利用 `path` 进行精确类型转换以及执行原始命令，帮助开发者正确获取原始字节数据。

UnifiedJedis.jsonGet 方法的数值类型转换问题

当通过 UnifiedJedis 客户端的 jsonGet 方法从 Redis 中检索 JSON 数据时，如果 JSON 结构中包含数值列表（例如，代表字节值的数组），Jedis 4.2.3 版本及其依赖的 JSON 处理库（如 Gson 或 org.json:json）在默认情况下会将所有数值解析为 double 类型。这导致即使原始数据是整数（如字节值），在 Java 中获取到的也会是 double 类型，并可能在打印时显示 .0 后缀。例如，一个存储为 [60, 63, 120] 的字节数组，在 jsonGet 返回的结果中可能显示为 [60.0, 63.0, 120.0]。

这种行为的根本原因在于这些 JSON 库在处理不确定数值类型时，通常会选择能够容纳最大范围的浮点类型（即 double）进行解析，以避免潜在的精度损失或溢出问题。

解决方案

针对这一问题，可以采用以下几种方法来正确地获取或处理字节数组数据。

1. 后处理获取到的数据

这种方法涉及获取完整的 Object 结果后，手动遍历并转换其中被错误识别为 double 的数值。由于 jsonGet 返回的 Object 通常是 LinkedHashMap 的实例，可以通过类型转换和迭代来识别并修正这些值。

实现思路：

将 jsonGet 返回的 Object 强制转换为 LinkedHashMap<String, Object>。
遍历 LinkedHashMap，找到包含字节数组的特定字段（例如示例中的 ReturnValue）。
如果该字段的值是一个 List<Double>，则遍历列表，将每个 double 值转换为 byte 或 int。在转换时，需要确保 double 值是整数且在 byte 的有效范围内。

示例（概念性代码）：

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

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";

        try {
            Object rawObject = client.jsonGet(key);
            System.out.println("原始输出: " + rawObject);

            if (rawObject instanceof LinkedHashMap) {
                LinkedHashMap<String, Object> dataMap = (LinkedHashMap<String, Object>) rawObject;

                // 假设ReturnValue在variables子字段下
                if (dataMap.containsKey("variables") && dataMap.get("variables") instanceof LinkedHashMap) {
                    LinkedHashMap<String, Object> variables = (LinkedHashMap<String, Object>) dataMap.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) {
                                Double doubleValue = (Double) item;
                                // 检查是否为整数且在byte范围内
                                if (doubleValue % 1.0 == 0.0 && doubleValue >= Byte.MIN_VALUE && doubleValue <= Byte.MAX_VALUE) {
                                    byteList.add(doubleValue.byteValue());
                                } else {
                                    // 处理非字节范围或非整数的double值
                                    System.err.println("警告: ReturnValue中包含非字节范围或非整数的double值: " + doubleValue);
                                    // 可以选择抛出异常或进行其他处理
                                }
                            } else {
                                // 处理非double类型的值，可能表示数据结构不一致
                                System.err.println("警告: ReturnValue中包含非double类型的值: " + item.getClass().getName());
                            }
                        }
                        System.out.println("转换后的 ReturnValue (字节列表): " + byteList);
                        // 可以将byteList重新设置回dataMap的相应位置
                        variables.put("ReturnValue", byteList);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            client.close();
        }
    }
}

登录后复制

注意事项： 这种方法通用性强，但需要开发者对 JSON 结构有清晰的了解，并手动编写类型检查和转换逻辑。如果 JSON 结构复杂，代码可能变得冗长。

2. 利用 Path 进行精确类型转换

Jedis 的 jsonGet 方法支持传入 Path 对象，这允许我们精确地指定要检索的 JSON 路径，并且可以指定返回的类型。这是获取特定字段并直接转换为所需类型的推荐方法。

实现思路：

通过 Path.of() 指定到 ReturnValue 字段的路径，并告知 jsonGet 方法期望返回的类型是 Byte[]。

钉钉 AI 助理

钉钉AI助理汇集了钉钉AI产品能力，帮助企业迈入智能新时代。

查看详情

示例代码：

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

public class JedisJsonDirectByteRetrieval {

    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 {
            // 注意：Jedis 4.2.3 的 jsonGet(key, class, path) 方法可能返回 List<Byte> 而非 Byte[]
            // 实际测试中，通常返回 List<T>。这里我们尝试 List<Byte>
            List<Byte> returnValueList = client.jsonGet(key, List.class, Path.of(".variables.ReturnValue"));
            // 如果实际返回的是 List<Double>，则需要进一步处理，或者尝试 Byte[].class
            // Jedis内部的转换机制可能仍将其解析为Double，但此方法通常能提供更直接的类型提示。
            // 
            // 更准确的做法是，如果确定Redis中存储的是数值数组，且期望字节类型，可以尝试如下：
            // List<Number> rawNumbers = client.jsonGet(key, List.class, Path.of(".variables.ReturnValue"));
            // List<Byte> byteList = new ArrayList<>();
            // for (Number num : rawNumbers) {
            //     byteList.add(num.byteValue());
            // }

            // 鉴于Jedis内部json解析的double倾向，最直接获取字节数组可能需要显式转换
            List<Double> doubleList = client.jsonGet(key, List.class, Path.of(".variables.ReturnValue"));
            List<Byte> byteList = new ArrayList<>();
            if (doubleList != null) {
                for (Double d : doubleList) {
                    if (d != null && d % 1.0 == 0.0 && d >= Byte.MIN_VALUE && d <= Byte.MAX_VALUE) {
                        byteList.add(d.byteValue());
                    } else {
                        System.err.println("警告: 路径 .variables.ReturnValue 包含非字节范围或非整数的double值: " + d);
                    }
                }
            }

            System.out.println("通过 Path 获取的 ReturnValue (字节列表): " + byteList);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            client.close();
        }
    }
}

登录后复制

说明： 尽管 jsonGet 提供了 Class<T> 参数，但由于底层 JSON 库的限制，直接指定 Byte[].class 或 List<Byte>.class 可能仍然无法避免 double 的中间解析。因此，通常需要先获取 List<Double> 或 List<Number>，然后再手动将其中的 double 值转换为 byte。这种方式的好处是能够精确地定位到所需字段，减少了遍历整个 LinkedHashMap 的开销。

3. 执行原始命令并手动解析结果

如果上述方法都无法满足需求，或者需要对 Redis 命令的执行和结果解析有更细粒度的控制，可以直接使用 executeCommand 方法发送原始的 Redis 命令，并手动解析返回的字节数据。

实现思路：

使用 client.executeCommand() 方法，传入 JsonProtocol.JsonCommand.GET 命令和相应的键。executeCommand 返回的 Object 通常是原始的字节数组或字符串，需要开发者自行处理其解码和反序列化。

示例代码：

import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.UnifiedJedis;
import redis.clients.jedis.args.CommandArguments;
import redis.clients.jedis.json.JsonProtocol;
import com.google.gson.Gson; // 假设使用Gson进行手动解析

import java.nio.charset.StandardCharsets;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.ArrayList;

public class JedisJsonRawCommand {

    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 命令
            Object rawResult = client.executeCommand(new CommandArguments(JsonProtocol.JsonCommand.GET).add(key));

            if (rawResult instanceof byte[]) {
                String jsonString = new String((byte[]) rawResult, StandardCharsets.UTF_8);
                System.out.println("原始命令返回的 JSON 字符串: " + jsonString);

                // 使用 Gson 或其他 JSON 库手动解析
                Gson gson = new Gson();
                // 假设我们知道顶层结构是 LinkedHashMap
                LinkedHashMap<String, Object> parsedMap = gson.fromJson(jsonString, LinkedHashMap.class);

                // 进一步提取和转换 ReturnValue 字段
                if (parsedMap != null && parsedMap.containsKey("variables") && parsedMap.get("variables") instanceof LinkedHashMap) {
                    LinkedHashMap<String, Object> variables = (LinkedHashMap<String, Object>) parsedMap.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) {
                            // Gson解析数字默认也是double
                            if (item instanceof Double) {
                                Double doubleValue = (Double) item;
                                if (doubleValue % 1.0 == 0.0 && doubleValue >= Byte.MIN_VALUE && doubleValue <= Byte.MAX_VALUE) {
                                    byteList.add(doubleValue.byteValue());
                                } else {
                                    System.err.println("警告: ReturnValue中包含非字节范围或非整数的double值: " + doubleValue);
                                }
                            }
                        }
                        System.out.println("通过原始命令和手动解析获取的 ReturnValue (字节列表): " + byteList);
                    }
                }
            } else {
                System.err.println("原始命令返回结果类型非 byte[]: " + rawResult.getClass().getName());
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            client.close();
        }
    }
}

登录后复制

注意事项： 这种方法提供了最大的灵活性，但也要求开发者承担全部的解析责任。你需要根据实际的 JSON 结构选择合适的 JSON 解析库（如 Gson, Jackson 等）进行手动反序列化。如果 JSON 结构非常复杂，手动解析会增加代码的复杂性。

总结与建议

UnifiedJedis.jsonGet() 方法在 Jedis 4.2.3 版本中将数值默认解析为 double 类型是其内部 JSON 库行为所致。为了正确获取字节数组，可以根据具体场景选择不同的解决方案：

数据后处理： 适用于 JSON 结构相对固定，且仅有少量字段需要转换的情况。代码相对简单，但不够优雅。
利用 Path 精确检索： 这是最推荐的方法，因为它允许你直接定位到目标字段。尽管可能仍需进行 double 到 byte 的二次转换，但它简化了数据获取的路径。
执行原始命令： 当需要完全控制 Redis 命令的执行和结果的解析时使用。这通常用于更高级的用例，或者当上述两种方法都无法满足需求时。

在实际开发中，建议优先考虑使用 Path 进行精确检索，并结合必要的类型转换。如果 Redis 中存储的 JSON 数据结构复杂且包含多种数值类型，理解并妥善处理这些类型转换是确保数据完整性和正确性的关键。

以上就是深入理解Jedis jsonGet 方法对字节数组的处理及解决方案的详细内容，更多请关注php中文网其它相关文章！