当前位置：首页 > 文章列表 > 文章 > java教程 > Jedis处理字节数组的jsonGet方法解析

Jedis处理字节数组的jsonGet方法解析

2025-11-08 18:18:39 0浏览收藏

## Jedis jsonGet 处理字节数组方法详解：避免 `.0` 后缀的困扰在使用 Jedis 4.2.3 客户端的 `UnifiedJedis.jsonGet()` 方法从 Redis 获取 JSON 数据时，你是否遇到了数值列表（本应是字节数组）被自动转换为 `double` 类型，导致数值后带有 `.0` 后缀的问题？本文深入剖析了这一现象背后的原因：Jedis 内部 JSON 解析库（如 Gson）默认将数值解析为 `double`，以避免精度损失。为了解决这一问题，本文提供了三种有效的解决方案，包括数据后处理、利用 `Path` 进行精确类型转换，以及执行原始命令并手动解析。无论你的 JSON 结构如何复杂，都能找到适合你的方法，确保正确获取原始字节数据，避免数据类型转换带来的困扰，提升数据处理的准确性和效率。

深入理解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。
遍历 LinkedHashMap，找到包含字节数组的特定字段（例如示例中的 ReturnValue）。
如果该字段的值是一个 List，则遍历列表，将每个 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[]。

示例代码：

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 参数，但由于底层 JSON 库的限制，直接指定 Byte[].class 或 List.class 可能仍然无法避免 double 的中间解析。因此，通常需要先获取 List 或 List，然后再手动将其中的 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方法解析》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多文章知识！