java - 仅解析大型 JSON 字符串中的一个字段

Question

我有一个以下格式的 JSON 字符串:

{

  "foo": "small_vale"  
  "baz": "large_value"
  "bar": "another_large_value"

}

如何有效地提取 foo 而忽略其余字段？基本上，我使用 Gson 并定义了一个“精益类”，如下所示:

MyClass {
  private String foo;
}

如果我确保 foo 首先出现在 JSON 字符串中，Gson 是否仍会扫描整个字符串，或者它是否足够聪明地停止？

我应该使用 JsonPath 吗？

Answer 1

要回答这个问题，我们需要看看如何解析 JSON。我假设您使用的是最简单的:

Test test = gson.fromJson(new FileReader(jsonFile), Test.class);

如果这是您的情况，那么您问题的答案是 Gson 不够聪明，无法做到这一点。如果你检查这个方法的实现，你会发现:

public <T> T fromJson(Reader json, Class<T> classOfT) throws JsonSyntaxException, JsonIOException {
    JsonReader jsonReader = newJsonReader(json);
    Object object = fromJson(jsonReader, classOfT);
    assertFullConsumption(object, jsonReader);
    return Primitives.wrap(classOfT).cast(object);
}

在方法返回值之前，它会检查整个 JSON 是否已被消耗，如果没有，则抛出 JsonIOException 。 Gson 内部使用给定类型的 TypeAdapter 实现。对于您的自定义 MyClass ，它将使用 ReflectiveTypeAdapterFactory.Adapter 类，该类将消耗整个 JSON 负载。为了避免这种情况，您可以编写自己的TypeAdapter:

class TestTypeAdapter extends TypeAdapter<Test> {

    @Override
    public void write(JsonWriter out, Test value) throws IOException {
        throw new IllegalStateException("Implement me!");
    }

    @Override
    public Test read(JsonReader in) throws IOException {
        if (in.peek() == JsonToken.NULL) {
            in.nextNull();
            return null;
        }

        Test test = new Test();

        try {
            in.beginObject();
            while (in.hasNext()) {
                String name = in.nextName();
                if (name.equals("foo")) {
                    test.setFoo(in.nextString());
                    break;
                }
            }
        } catch (IllegalStateException e) {
            throw new JsonSyntaxException(e);
        }

        return test;
    }
}

简单用法:

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonSyntaxException;
import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.JsonWriter;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

public class GsonApp {

    public static void main(String[] args) throws Exception {
        File jsonFile = new File("./resource/test.json").getAbsoluteFile();
        Gson gson = new GsonBuilder().create();

        Test test = gson.fromJson(new FileReader(jsonFile), Test.class);
        Test test1 = new TestTypeAdapter().fromJson(new FileReader(jsonFile));

        System.out.println(test);
        System.out.println(test1);
    }
}

class Test {

    private String foo;

    public String getFoo() {
        return foo;
    }

    public void setFoo(String foo) {
        this.foo = foo;
    }

    @Override
    public String toString() {
        return "Test{" +
                "foo='" + foo + '\'' +
                '}';
    }
}

上面的代码打印:

Test{foo='small_value'}
Test{foo='small_value'}

正如您所看到的，在这两种情况下我们都解析了我们的小值。您可以测试此代码并计算自定义 TypeAdapter 对于您的 JSON 负载的速度有多快。

但是，如果您的情况非常复杂，并且需要解析更多 JSON 才能找到您的值，请尝试使用 JSONPath 解决方案。你可以从这个问题开始:how to parse a huge JSON file without loading it in memory .