使用 Spring 批处理读取非常复杂的 JSON

Question

我的目标是使用 Spring Batch 读取一个非常复杂的 JSON。 下面是样本 JSON。

{
  "order-info" : {
  "order-number" : "Test-Order-1"
  "order-items" : [
  {
   "item-id" : "4144769310"
   "categories" : [
    "ABCD",
    "DEF"
   ],
   "item_imag" : "http:// "
   "attributes: {
      "color" : "red"

   },
   "dimensions" : {

   },
   "vendor" : "abcd",

   },
   {
    "item-id" : "88888",

    "categories" : [
    "ABCD",
    "DEF"
   ],
   .......

我知道我需要创建一个自定义 ItemReader 来解析这个 JSON。请给我一些指示。 我真是一头雾水。

我现在不使用 CustomItemReader。 我正在使用 Java POJO。 我的 JsonItemReader 如下所示：

@Bean
 public JsonItemReader<Trade> jsonItemReader() {

        ObjectMapper objectMapper = new ObjectMapper();

       JacksonJsonObjectReader<Trade> jsonObjectReader =
                new JacksonJsonObjectReader<>(Trade.class);

       jsonObjectReader.setMapper(objectMapper);

        return new JsonItemReaderBuilder<Trade>()
                .jsonObjectReader(jsonObjectReader)
                .resource(new ClassPathResource("search_data_1.json"))
                .name("tradeJsonItemReader")
                .build();
}

我现在得到的例外是：

java.lang.IllegalStateException：Json 输入 stream 必须以 Json 对象的数组开头

从本论坛的类似帖子中，我了解到我需要使用 JsonObjectReader。 “您可以实现它以读取单个 json object 并将其与 JsonItemReader 一起使用（在构造时或使用设置器） ”。

我如何在@施工时间或使用 setter 中执行此操作？ 请分享一些相同的代码片段。

MultiResourceItemReader 的委托仍应是 JsonItemReader。 您只需要将自定义 JsonObjectReader 与 JsonItemReader 一起使用，而不是 JacksonJsonObjectReader。 在视觉上，这将是：MultiResourceItemReader -- 委托 --> JsonItemReader -- 使用 --> 您的自定义 JsonObjectReader。

你能分享上面的代码片段吗？

Answer 1

JacksonJsonItemReader 旨在从已经是数组节点的根节点进行解析，因此它希望您的 json 以“[”开头。

如果你想解析一个复杂的 object——在这种情况下，它在到达数组之前有许多父节点/属性——你应该写一个阅读器。 做起来真的很简单，你可以遵循 JacksonJsonObjectReader 的结构。 下面是一个通用阅读器示例，用于复杂的 object 以及相应的单元测试。

单元测试

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.BlockJUnit4ClassRunner;
import org.springframework.core.io.ByteArrayResource;

import com.example.batch_experiment.dataset.Dataset;
import com.example.batch_experiment.dataset.GenericJsonObjectReader;
import com.example.batch_experiment.json.InvalidArrayNodeException;
import com.example.batch_experiment.json.UnreachableNodeException;
import com.fasterxml.jackson.databind.ObjectMapper;

@RunWith(BlockJUnit4ClassRunner.class)
public class GenericJsonObjectReaderTest {

GenericJsonObjectReader<Dataset> reader;

@Before
public void setUp() {       
    reader = new GenericJsonObjectReader<Dataset>(Dataset.class, "results");
}

@Test
public void shouldRead_ResultAsRootNode() throws Exception {
    reader.open(new ByteArrayResource("{\"result\":{\"results\":[{\"id\":\"a\"}]}}".getBytes()) {});
    Assert.assertTrue(reader.getDatasetNode().isArray());
    Assert.assertFalse(reader.getDatasetNode().isEmpty());
}

@Test
public void shouldIgnoreUnknownProperty() throws Exception {
    String jsonStr = "{\"result\":{\"results\":[{\"id\":\"a\", \"aDifferrentProperty\":0}]}}";
    reader.open(new ByteArrayResource(jsonStr.getBytes()) {});
    Assert.assertTrue(reader.getDatasetNode().isArray());
    Assert.assertFalse(reader.getDatasetNode().isEmpty());
}

@Test
public void shouldIgnoreNullWithoutQuotes() throws Exception {
    String jsonStr = "{\"result\":{\"results\":[{\"id\":\"a\",\"name\":null}]}}";
    try {
        reader.open(new ByteArrayResource(jsonStr.getBytes()) {});
        Assert.assertTrue(reader.getDatasetNode().isArray());
        Assert.assertFalse(reader.getDatasetNode().isEmpty());
    } catch (Exception e) {
        Assert.fail(e.getMessage());
    }
}

@Test
public void shouldThrowException_OnNullNode() throws Exception {
    boolean exceptionThrown = false;
    try {           
        reader.open(new ByteArrayResource("{}".getBytes()) {});
    } catch (UnreachableNodeException e) {
        exceptionThrown = true;
    }
    Assert.assertTrue(exceptionThrown);
}

@Test
public void shouldThrowException_OnNotArrayNode() throws Exception {
    boolean exceptionThrown = false;
    try {           
        reader.open(new ByteArrayResource("{\"result\":{\"results\":{}}}".getBytes()) {});
    } catch (InvalidArrayNodeException e) {
        exceptionThrown = true;
    }
    Assert.assertTrue(exceptionThrown);
}

@Test
public void shouldReadObjectValue() {
    try {
        reader.setJsonParser(new ObjectMapper().createParser("{\"id\":\"a\"}"));
        Dataset dataset = reader.read();
        Assert.assertNotNull(dataset);
        Assert.assertEquals("a", dataset.getId());
    } catch (Exception e) {
        Assert.fail(e.getMessage());
    }
}

}

读者：

import java.io.IOException;
import java.io.InputStream;
import java.util.logging.Logger;

import org.springframework.batch.item.ParseException;
import org.springframework.batch.item.json.JsonObjectReader;
import org.springframework.core.io.Resource;

import com.example.batch_experiment.json.InvalidArrayNodeException;
import com.example.batch_experiment.json.UnreachableNodeException;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;

/*
 * This class follows the structure and functions similar to JacksonJsonObjectReader, with 
 * the difference that it expects a object as root node, instead of an array.
 */
public class GenericJsonObjectReader<T> implements JsonObjectReader<T>{

Logger logger = Logger.getLogger(GenericJsonObjectReader.class.getName());

ObjectMapper mapper = new ObjectMapper();
private JsonParser jsonParser;
private InputStream inputStream;

private ArrayNode targetNode;
private Class<T> targetType;
private String targetPath;

public GenericJsonObjectReader(Class<T> targetType, String targetPath) {
    super();
    this.targetType = targetType;
    this.targetPath = targetPath;
}

public JsonParser getJsonParser() {
    return jsonParser;
}

public void setJsonParser(JsonParser jsonParser) {
    this.jsonParser = jsonParser;
}

public ArrayNode getDatasetNode() {
    return targetNode;
}

/*
 * JsonObjectReader interface has an empty default method and must be implemented in this case to set 
 * the mapper and the parser
 */
@Override
public void open(Resource resource) throws Exception {
    logger.info("Opening json object reader");
    this.inputStream = resource.getInputStream();
    JsonNode jsonNode = this.mapper.readTree(this.inputStream).findPath(targetPath);
    if (!jsonNode.isMissingNode()) {
        this.jsonParser = startArrayParser(jsonNode);
        logger.info("Reader open with parser reference: " + this.jsonParser);
        this.targetNode = (ArrayNode) jsonNode; // for testing purposes
    } else {
        logger.severe("Couldn't read target node " + this.targetPath);
        throw new UnreachableNodeException();
    }
}


@Override
public T read() throws Exception {
    try {
        if (this.jsonParser.nextToken() == JsonToken.START_OBJECT) {
            T result = this.mapper.readValue(this.jsonParser, this.targetType);
            logger.info("Object read: " + result.hashCode());
            return result;
        }
    } catch (IOException e) {
        throw new ParseException("Unable to read next JSON object", e);
    }
    return null;
}

/**
 * Creates a new parser from an array node
 */
private JsonParser startArrayParser(JsonNode jsonArrayNode) throws IOException {
    JsonParser jsonParser = this.mapper.getFactory().createParser(jsonArrayNode.toString());
    if (jsonParser.nextToken() == JsonToken.START_ARRAY) {
        return jsonParser;
    } else {
        throw new InvalidArrayNodeException();
    }
}

@Override
public void close() throws Exception {
    this.inputStream.close();
    this.jsonParser.close();
}

}