当前位置：首页 > 文章列表 > 文章 > java教程 > JedisjsonGet返回.0问题解决方法

JedisjsonGet返回.0问题解决方法

2025-11-01 23:30:56 0浏览收藏

在使用Jedis客户端的`jsonGet`方法从Redis获取JSON数据时，开发者可能会遇到字节数组中的数值被转换为`double`类型，并在末尾显示`.0`的问题。这通常是由于Jedis底层使用的JSON库（如Gson）默认将数字类型统一转换为`double`所致。本文针对这一问题，提出了三种有效的解决方案：一是数据后处理，即手动将`double`转换回`byte`；二是精确获取，利用`jsonGet`方法指定返回类型和JSON路径，直接获取字节数组；三是执行原始Redis命令，绕过Jedis的JSON解析，完全掌控数据解析过程。推荐使用第二种方法，即通过指定类型和路径进行精确获取，因其简洁高效，能有效解决Jedis `jsonGet`返回值类型转换问题，确保数据准确性。

Jedis jsonGet 方法返回字节数组值末尾出现 .0 的处理策略

当使用Jedis客户端的`jsonGet`方法从Redis获取JSON数据时，如果其中包含字节数组（如XML字符串的字节表示），可能会因底层JSON库（如Gson或org.json）的默认行为，导致数字被统一上转型为`double`类型，从而在输出中显示`.0`后缀。本文将深入探讨此问题产生的原因，并提供三种有效的解决方案：数据后处理、通过指定类型和路径进行精确获取，以及执行原始Redis命令以完全控制数据解析。

Jedis jsonGet 返回值类型转换问题解析

在使用UnifiedJedis的jsonGet方法获取存储在Redis中的JSON数据时，开发者可能会遇到一个常见的问题：原本期望获取的是字节数组（例如，一个XML字符串的ASCII值序列），但实际返回的数值却带有.0后缀，表现为double类型（例如，[60.0, 63.0, 120.0, ...]）。

这个问题通常源于Jedis内部使用的JSON处理库，如Gson或org.json:json。这些库在默认情况下，会将JSON中的所有数字类型统一上转型为Java的double类型，以确保兼容性和精度，尤其是在无法确定原始数字具体类型时。因此，即使Redis中存储的是表示字节的整数值，经过这些库解析后，也会被转换为double类型。

例如，以下Java代码片段展示了该问题：

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

public class JedisJsonGetIssue {
    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";

        // 假设Redis中存储的JSON数据在.variables.ReturnValue路径下包含一个字节数组
        // 例如：{"variables": {"ReturnValue": [60, 63, 120, ...]}}

        Object object = client.jsonGet(key);
        System.out.println(object);
        // 预期输出可能包含：ReturnValue=[60.0, 63.0, 120.0, ...]
        client.close();
    }
}

为了解决这个问题，并获取原始的字节数组表示，我们可以采用以下几种策略。

解决方案

1. 数据后处理：手动转换 double 到 byte

一种直接的方法是在获取到Object类型的结果后，对其进行遍历和类型转换。由于jsonGet通常返回一个Map或List的嵌套结构，我们可以将其强制转换为LinkedHashMap，然后定位到包含double值的字段，并将其转换回byte类型。

实现思路：

将jsonGet返回的Object强制转换为LinkedHashMap。
递归遍历LinkedHashMap，找到目标路径（例如，.variables.ReturnValue）。
对于ReturnValue字段下的List，将其中的每个Double值转换为Byte。

示例代码（概念性）：

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

public class JedisJsonPostProcess {
    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 result = client.jsonGet(key);

            if (result instanceof LinkedHashMap) {
                LinkedHashMap<String, Object> rootMap = (LinkedHashMap<String, Object>) result;
                if (rootMap.containsKey("variables") && rootMap.get("variables") instanceof LinkedHashMap) {
                    LinkedHashMap<String, Object> variablesMap = (LinkedHashMap<String, Object>) rootMap.get("variables");
                    if (variablesMap.containsKey("ReturnValue") && variablesMap.get("ReturnValue") instanceof List) {
                        List<?> rawReturnValue = (List<?>) variablesMap.get("ReturnValue");
                        List<Byte> byteReturnValue = new ArrayList<>();
                        for (Object val : rawReturnValue) {
                            if (val instanceof Double) {
                                byteReturnValue.add(((Double) val).byteValue());
                            } else {
                                // 处理非Double类型，例如抛出异常或记录警告
                                System.err.println("Warning: Unexpected type in ReturnValue list: " + val.getClass().getName());
                            }
                        }
                        variablesMap.put("ReturnValue", byteReturnValue); // 更新为正确的字节列表
                        System.out.println("Processed ReturnValue: " + byteReturnValue);
                    }
                }
                System.out.println("Full processed object: " + rootMap);
            } else {
                System.out.println("Unexpected result type: " + result.getClass().getName());
            }
        } finally {
            client.close();
        }
    }
}

注意事项：

这种方法需要在客户端进行额外的处理逻辑，增加了代码复杂度和运行时开销。
需要明确知道哪些字段包含需要转换的double值。
对于复杂的JSON结构，遍历和转换可能变得繁琐。

2. 精确获取：使用 jsonGet 指定类型和路径

Jedis提供了更强大的jsonGet重载方法，允许你指定期望的返回类型和JSON路径。这是解决此类问题的推荐方法，因为它直接在Jedis层面处理类型转换，避免了手动后处理。

实现思路：

使用client.jsonGet(key, Class clazz, Path... paths)方法。
clazz参数指定为Byte[].class，表明我们期望获取一个字节数组。
Path.of(".variables.ReturnValue")精确指定要获取的JSON路径。

示例代码：

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

public class JedisJsonGetWithType {
    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 {
            // 直接获取.variables.ReturnValue路径下的字节数组
            Byte[] returnValue = client.jsonGet(key, Byte[].class, Path.of(".variables.ReturnValue"));

            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("]");

                // 示例：将字节数组转换回字符串
                byte[] primitiveBytes = new byte[returnValue.length];
                for (int i = 0; i < returnValue.length; i++) {
                    primitiveBytes[i] = returnValue[i];
                }
                System.out.println("Decoded String: " + new String(primitiveBytes));
            } else {
                System.out.println("ReturnValue not found or could not be cast to Byte[].");
            }
        } finally {
            client.close();
        }
    }
}

注意事项：

此方法要求Jedis版本支持Path类（通常在Jedis 4.x及更高版本中可用）。
需要准确知道目标数据的JSON路径。
如果路径不存在或类型不匹配，可能会返回null或抛出异常。

3. 原始命令执行：绕过Jedis的JSON解析

对于需要极致控制或处理Jedis默认JSON解析行为无法满足的场景，可以直接执行原始的Redis命令。这种方法完全绕过了Jedis的内置JSON解析器，允许开发者自行处理Redis返回的原始数据。

实现思路：

使用client.executeCommand(CommandArguments arguments)方法。
构建一个CommandArguments对象，包含JsonProtocol.JsonCommand.GET命令和键。
获取返回的原始Object，并根据Redis响应格式进行手动解析。对于JSON GET命令，通常会返回一个字符串。

示例代码：

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 com.google.gson.reflect.TypeToken;
import java.lang.reflect.Type;
import java.util.List;
import java.util.LinkedHashMap;

public class JedisRawCommand {
    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 String) {
                String jsonString = (String) rawResult;
                System.out.println("Raw JSON String from Redis: " + jsonString);

                // 手动解析JSON字符串
                Gson gson = new Gson();
                // 假设我们知道顶层是一个LinkedHashMap
                Type type = new TypeToken<LinkedHashMap<String, Object>>() {}.getType();
                LinkedHashMap<String, Object> parsedMap = gson.fromJson(jsonString, type);

                // 继续手动解析到ReturnValue
                if (parsedMap != null && parsedMap.containsKey("variables")) {
                    LinkedHashMap<String, Object> variables = (LinkedHashMap<String, Object>) parsedMap.get("variables");
                    if (variables != null && variables.containsKey("ReturnValue")) {
                        // 在Gson解析时，如果JSON中的数字是整数，Gson默认会解析为Double
                        // 所以这里仍然需要从List<Double>转换为List<Byte>
                        List<Double> rawBytesAsDoubles = (List<Double>) variables.get("ReturnValue");
                        if (rawBytesAsDoubles != null) {
                            List<Byte> actualBytes = new ArrayList<>();
                            for (Double d : rawBytesAsDoubles) {
                                actualBytes.add(d.byteValue());
                            }
                            System.out.println("Manually parsed ReturnValue as Byte array: " + actualBytes);
                        }
                    }
                }
            } else {
                System.out.println("Unexpected raw result type: " + rawResult.getClass().getName());
            }
        } finally {
            client.close();
        }
    }
}

注意事项：

这种方法提供了最大的灵活性，但也要求开发者完全负责JSON字符串的解析。
需要引入额外的JSON解析库（如Gson、Jackson等）。
错误处理和类型转换的复杂性将由开发者承担。

总结与最佳实践

Jedis jsonGet方法返回double类型而非原始字节值的问题，主要是由于其底层JSON解析库的默认行为。为了解决这个问题，我们提供了三种策略：

数据后处理：适用于对现有代码改动最小，但需要手动遍历和转换的场景。适用于JSON结构已知且相对简单的情况。
指定类型和路径获取：这是最推荐的方法，尤其是在Jedis 4.x及更高版本中。它利用Jedis的强大功能，直接在获取数据时进行类型转换和路径定位，代码简洁高效。
原始命令执行：当需要完全控制JSON解析过程，或者Jedis的内置功能无法满足特定需求时，可以采用此方法。但它会增加客户端的复杂性，需要引入额外的JSON库并进行手动解析。

在大多数情况下，使用client.jsonGet(key, Byte[].class, Path.of(".variables.ReturnValue"))这种指定类型和路径的方法是最佳实践，因为它兼顾了代码的简洁性、效率和准确性。只有在特定需求下，例如需要处理非常规的JSON数据或对解析过程有极高定制要求时，才考虑采用后两种更复杂的方法。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。