5

i have a json file with many elements like these:

{ 
"code" : "hfuiew89", 
"type" : "location", 
"coordinates" : [ { "lat" : 40.9861, "lon" : 29.1046, "index" : 1 }, 
          { "lat" : 40.9976, "lon" : 29.1153, "index" : 2 }, 
          { "lat" : 40.9809, "lon" : 29.2194, "index" : 3 }] 
}
{ 
"code" : "klsdsjh", 
"type" : "location", 
"relatedTags" : [ "kolmha" ], 
"coordinates" : [ { "lat" : 40.9808, "lon" : 29.1605, "index" : 1 }, 
              { "lat" : 40.9965, "lon" : 29.1672, "index" : 2 }] 
}

i want to read that file with gson but all examples i found are only for one element. therefore after reading the first one, throws 'Expected EOF' exception. how can i overcome this?

Improve this question
1
  • 2
    JSON is meant to be a single entity (be that an object, or an array) - and what you've got is multiple objects. What you really want in this situation is an array at the top level, with each object as an element in it. Can you affect the generation of this JSON, or are you stuck with this format? Commented Jun 28, 2012 at 21:59

2 Answers 2

Reset to default
10

For what it's worth...

The following statement is incorrect. Gson does not have a built in feature to simply handle deserialization of such a JSON sequence. (See comments.)

If switching JSON-to/from-Java APIs is an option, Jackson does have such a feature, as demonstrated below.

input.json

{
"name":"A"
}
{
"name":"B"
}

JacksonFoo.java

import static com.fasterxml.jackson.annotation.JsonAutoDetect.Visibility.ANY;
import static com.fasterxml.jackson.annotation.PropertyAccessor.FIELD;

import java.io.File;
import java.util.Iterator;

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonFoo
{
  public static void main(String[] args) throws Exception
  {
    ObjectMapper mapper = new ObjectMapper().setVisibility(FIELD, ANY);
    Iterator<Thing> thingsIterator = mapper.reader(Thing.class).readValues(new File("input.json"));
    while (thingsIterator.hasNext())
    {
      System.out.println(thingsIterator.next());
    }
  }
}

class Thing
{
  private String name;

  @Override
  public String toString()
  {
    return String.format("Thing: name=%s", name);
  }
}

Output:

Thing: name=A
Thing: name=B

Update: A similar solution using Gson.

GsonFoo.java

import java.io.FileReader;

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonStreamParser;

public class GsonFoo
{
  public static void main(String[] args) throws Exception
  {
    Gson gson = new GsonBuilder().create();

    JsonStreamParser parser = new JsonStreamParser(new FileReader("input.json"));
    while(parser.hasNext())
    {
      System.out.println(gson.fromJson(parser.next(), Thing.class));
    }
  }
}
Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

This post is incorrect. Gson does have that (mis)feature. It's called JsonStreamParser and the documentation is here: google-gson.googlecode.com/svn/trunk/gson/docs/javadocs/com/…
Ah, neat. I was thrown by the use of the word "Stream" in the GSON API. I just assumed "Stream" referred to parsing JSON one streaming token at a time, as opposed to binding JSON data to objects/arrays.
This's exactly what I was looking for. It's extremely useful when you want to write multiple JSON nodes to a file efficiently: you just append the new element instead of parsing an array, appending an element, and writing the whole thing back to the disk.
3

Greg is right, this is incorrect JSON, and you should try to generate valid JSON, that is prepend "[" at the beginning, append "]" at the end, and separate each element with a comma (","), so that it is a JSON array of JSON object.

However, if you cannot change the format you have, consider it "a string containing a concatenation of well formed JSON fragments". Approaching it that way, break the big string into smaller, valid json strings, and parse them one by one.

To break the big string into single fragments you can simply count the brackets. With a "pre-parser" that copies stuff into a buffer (a StringBuilder?), increments a counter each time it encounters a "{", decreases it each time it enouters a "}", and if the counter is at zero pass the buffer string to gson for parsing, clear the buffer and go on to the end of the file.

You can even use that pre-parser to convert it to valid json, simply appending a "," when the counter reaches zero, and the passing everything to gson for a single parsing, but that could mean loading everything into ram, and I don't know how big your file is.

Improve this answer

6 Comments

Going along with this, you could simply create your file as an array of JSON Objects. However you might run into memory issues if there are too many entities in the array. Otherwise, a separated string of JSON entities is better, and will let you load only part of the file at a time.
Yes, that is what I was trying to express : a single file big json array, and a single call for parsing, could seem easier, but could also mean loading everything in ram; while going "step by step" could you let handle entities one by one ... this is SAX against DOM again, but now that it is called JSON it makes it sound much more k00l.
Haha, so true. Although JSON does seem less verbose (no closing tags for example), and is also provides a very easy means to pass data to Javascript, which is all the rage these days and hence probably one of the reasons for the big rise of JSON.
Yes, no closing tags .. very nice as long as you don't have to edit a json file manually, or have a very very simple structure, but what when the last few lines are 10s of closing brackets? :D If all we needed was a better format than XML for machine to machine communications, JSON is even too verbose for that task.. but I think we are going offtopic :D
Agreed. It's all about Avro or Thrift anyway :P
|

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.