Bester Ansatz, um riesige (extra große) JSON-Dateien zu analysieren

Question 1

Ich versuche, eine riesige JSON-Datei (wie z http://eu.battle.net/auction-data/258993a3c6b974ef3e6f22ea6f822720/auctions.json) mit der gson-Bibliothek (http://code.google.com/p/google-gson/) in Java.

Ich würde gerne wissen, was der beste Ansatz ist, um diese Art von großer Datei (etwa 80.000 Zeilen) zu analysieren, und ob Sie vielleicht eine gute API kennen, die mir bei der Verarbeitung helfen kann.

Einige Ideen

Zeile für Zeile lesen und das JSON-Format loswerden: aber das ist Unsinn.
Reduzieren Sie die JSON-Datei, indem Sie diese Datei in viele andere aufteilen: aber ich habe keine gute Java-API dafür gefunden.

Verwenden Sie diese Datei direkt als Nicht-Sql-Datenbank, behalten Sie die Datei und verwenden Sie sie als meine Datenbank.

Question 2

Sie müssen nicht zu Jackson wechseln. Gson 2.1 führte ein neues ein TypeAdapter Schnittstelle, die Mixed-Tree- und Streaming-Serialisierung und -Deserialisierung ermöglicht.

Die API ist effizient und flexibel. Sehen Gsons Streaming-Dokument für ein Beispiel zum Kombinieren von Baum und Bindung Modi. Dies ist absolut besser als gemischte Streaming- und Baummodi; Mit der Bindung verschwenden Sie keinen Speicher, um eine Zwischendarstellung Ihrer Werte zu erstellen.

Wie Jackson verfügt Gson über APIs, um einen unerwünschten Wert rekursiv zu überspringen; Gson nennt das überspringenWert().

Question 3

Ich werde vorschlagen, einen Blick darauf zu werfen Jackson API Es ist sehr einfach, die Streaming- und Baummodell-Parsing-Optionen zu kombinieren: Sie können sich auf Streaming-Weise durch die Datei als Ganzes bewegen und dann einzelne Objekte in eine Baumstruktur einlesen.

Als ein Beispielnehmen wir die folgende Eingabe:

{ 
  "records": [ 
    {"field1": "aaaaa", "bbbb": "ccccc"}, 
    {"field2": "aaa", "bbb": "ccc"} 
  ] ,
  "special message": "hello, world!" 
}

Stellen Sie sich vor, die Felder seien spärlich oder die Datensätze hätten eine komplexere Struktur.

Das folgende Snippet veranschaulicht, wie diese Datei mit einer Kombination aus Stream- und Tree-Model-Parsing gelesen werden kann. Jeder einzelne Datensatz wird in einer Baumstruktur gelesen, aber die Datei wird nie vollständig in den Speicher gelesen, wodurch es möglich ist, Gigabyte große JSON-Dateien mit minimalem Speicherverbrauch zu verarbeiten.

import org.codehaus.jackson.map.*;
import org.codehaus.jackson.*;

import java.io.File;

public class ParseJsonSample {
    public static void main(String[] args) throws Exception {
        JsonFactory f = new MappingJsonFactory();
        JsonParser jp = f.createJsonParser(new File(args[0]));
        JsonToken current;
        current = jp.nextToken();
        if (current != JsonToken.START_OBJECT) {
            System.out.println("Error: root should be object: quiting.");
            return;
        }
        while (jp.nextToken() != JsonToken.END_OBJECT) {
            String fieldName = jp.getCurrentName();
            // move from field name to field value
            current = jp.nextToken();
            if (fieldName.equals("records")) {
                if (current == JsonToken.START_ARRAY) {
                    // For each of the records in the array
                    while (jp.nextToken() != JsonToken.END_ARRAY) {
                        // read the record into a tree model,
                        // this moves the parsing position to the end of it
                        JsonNode node = jp.readValueAsTree();
                        // And now we have random access to everything in the object
                        System.out.println("field1: " + node.get("field1").getValueAsText());
                        System.out.println("field2: " + node.get("field2").getValueAsText());
                    }
                } else {
                    System.out.println("Error: records should be an array: skipping.");
                    jp.skipChildren();
                }
            } else {
                System.out.println("Unprocessed property: " + fieldName);
                jp.skipChildren();
            }
        }
    }
}

Wie Sie sich vorstellen können, gibt der nextToken()-Aufruf jedes Mal das nächste Parsing-Ereignis aus: Startobjekt, Startfeld, Startarray, Startobjekt, …, Endobjekt, …, Endarray, …

Der jp.readValueAsTree() call ermöglicht es, das, was sich an der aktuellen Parsing-Position befindet, ein JSON-Objekt oder -Array, in Jacksons generisches JSON-Baummodell einzulesen. Sobald Sie dies haben, können Sie wahllos auf die Daten zugreifen, unabhängig von der Reihenfolge, in der die Dinge in der Datei erscheinen (im Beispiel sind Feld1 und Feld2 nicht immer in der gleichen Reihenfolge). Jackson unterstützt auch das Mapping auf Ihre eigenen Java-Objekte. Das jp.skipChildren() ist praktisch: Es ermöglicht das Überspringen eines kompletten Objektbaums oder eines Arrays, ohne dass Sie alle darin enthaltenen Ereignisse durchlaufen müssen.

Question 4

Deklaratives Stream-Mapping (DSM) Mit der Bibliothek können Sie Zuordnungen zwischen Ihren JSON- oder XML-Daten und Ihrem POJO definieren. Sie müssen also keinen benutzerdefinierten Parser schreiben. Es hat eine leistungsstarke Unterstützung für Scripting (Javascript, Groovy, JEXL). Sie können Daten filtern und transformieren, während Sie lesen. Sie können Funktionen für partielle Datenoperationen aufrufen, während Sie Daten lesen. DSM liest Daten als Stream, sodass sehr wenig Speicher verwendet wird.

Zum Beispiel,

{
    "company": {
         ....
        "staff": [
            {
                "firstname": "yong",
                "lastname": "mook kim",
                "nickname": "mkyong",
                "salary": "100000"
            },
            {
                "firstname": "low",
                "lastname": "yin fong",
                "nickname": "fong fong",
                "salary": "200000"
            }
        ]
    }
}

Stellen Sie sich vor, das obige Snippet ist Teil riesiger und komplexer JSON-Daten. wir wollen nur bekommen Zeug, das ein höheres Gehalt hat als 10000.

Zunächst müssen wir Mapping-Definitionen wie folgt definieren. Wie Sie sehen, handelt es sich lediglich um eine Yaml-Datei, die die Zuordnung zwischen POJO-Feldern und JSON-Datenfeldern enthält.

result:
      type: object     # result is map or a object.
      path: /.+staff  # path is regex. its match with /company/staff
      function: processStuff  # call processStuff function when /company/stuff tag is closed
      filter: self.data.salary>10000   # any expression is valid in JavaScript, Groovy or JEXL
      fields:
        name:  
          path: firstname
        sureName:
          path: lastname
        userName:
          path: nickname
        salary: long

FunctionExecutor für Prozessmitarbeiter erstellen.

FunctionExecutor processStuff=new FunctionExecutor(){

            @Override
            public void execute(Params params) {

                // directly serialize Stuff class
                //Stuff stuff=params.getCurrentNode().toObject(Stuff.class);

                Map<String,Object> stuff= (Map<String,Object>)params.getCurrentNode().toObject();
                System.out.println(stuff);
                // process stuff ; save to db. call service etc.
            }
        };

Verwenden Sie DSM, um JSON zu verarbeiten

     DSMBuilder builder = new DSMBuilder(new File("path/to/mapping.yaml")).setType(DSMBuilder.TYPE.XML);

       // register processStuff Function
        builder.registerFunction("processStuff",processStuff);

        DSM dsm= builder.create();
        Object object =  dsm.toObject(xmlContent);

Ausgabe: (Nur Sachen mit einem Gehalt von mehr als 10000 sind enthalten)

{firstName=low, lastName=yin fong, nickName=fong fong, salary=200000}