Umwandlung von Dokument-Objekten in MongoDB 3 POJOS

Spare ich ein Objekt mit java.util.Feld "Datum" in eine MongoDB 3.2 Instanz.

ObjectMapper mapper = new ObjectMapper();
String json = mapper.writeValueAsString(myObject);
collection.insertOne(Document.parse(json));

die Zeichenfolge enthält:

"captured": 1454549266735

dann lese ich es aus dem MongoDB-Instanz:

    final Document document = collection.find(eq("key", value)).first();
    final String json = document.toJson();
    ObjectMapper mapper = new ObjectMapper();
    mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    xx = mapper.readValue(json, MyClass.class);

die Deserialisierung schlägt fehl:

java.lang.RuntimeException: com.fasterxml.jackson.databind-Methode.JsonMappingException:
Kann nicht deserialisiert Instanz von java.util.Datum aus START_OBJECT token

Sehe ich, dass die json-string erstellt von "Dokument.toJson()" enthält:

"captured": {
    "$numberLong": "1454550216318"
}

statt, was war es ursprünglich ("eingefangen": 1454549266735)
MongoDB docs sagen, Sie begann mit "MongoDB Erweitert Json". Ich habe versucht, sowohl Jackson 1 und 2 analysieren - kein Glück.

was ist der einfachste Weg zu konvertieren diese Dokument-Objekte zur Verfügung gestellt von MongoDB 3 Java POJOs? vielleicht kann ich überspringen toJson () - Schritt insgesamt?

Versuchte ich mongojack -, die man nicht unterstützen MongoDB3.

Sah paar anderen POJO-Mapper aufgeführt, die auf MongoDB docs Seite - Sie alle benötigen um Ihre individuelle Anmerkungen zu Java-Klassen.

InformationsquelleAutor Alex | 2016-02-04

12

Sollten Sie festlegen und verwenden eigener JsonWriterSettings Feinabstimmung JSON-generation:
```
 JsonWriterSettings settings = JsonWriterSettings.builder()
         .int64Converter((value, writer) -> writer.writeNumber(value.toString()))
         .build();

 String json = new Document("a", 12).append("b", 14L).toJson(settings);
```
Produzieren:
```
 { "a" : 12, "b" : 14 }
```
Wenn Sie nicht verwenden Sie benutzerdefinierte Einstellungen dann-Dokument erzeugen wird, verlängert json:
```
 { "a" : 12, "b" : { "$numberLong" : "14" } }
```
- Edit: nur ein einfaches und schlichtes Danke.
- Perfekte Antwort! Danke!
- Ein potentielles problem bei diesem Ansatz ist, dass große Werte von longs verlieren Präzision. Einige JSON-Implementierungen verwenden Sie nur verdoppelt. Diese haben einen 52-bit-Mantisse, was ist 12 weniger bits als eine lange. Zum Glück, epochale Zeit in Millisekunden, die derzeit benötigt nur 31 bits, so erhalten wir mit diesem Weg in vielen Fällen (für 143.000 Mitarbeiter Jahre), aber Vorsicht!
InformationsquelleAutor caiiiycuk
4

Dieser sieht aus wie Mongo-Java-Treiber-bug, bei dem Dokument.toJson profuces nicht-standard-JSON-auch wenn JsonMode.STRENGE verwendet. Dieses problem wird im folgenden beschrieben Fehler https://jira.mongodb.org/browse/JAVA-2173, für die ich Sie ermutigen, zu Stimmen.

Eine Problemumgehung ist die Verwendung von com.mongodb.util.JSON.serialize(document).
- com.mongodb.util.JSON.serialize(document) wurde deprecated in neuen Versionen
InformationsquelleAutor Aleksey Korolev

Es sieht aus wie Sie mit Datums-Objekt in "myObject". In diesem Fall sollten Sie eine DateSerializer implementiert JsonSerializer<LocalDate>, JsonDeserializer<LocalDate> und registrieren Sie es mit GsonBuilder. Beispielcode folgt:

public class My_DateSerializer implements JsonSerializer<LocalDate>,
                                                          JsonDeserializer<LocalDate> {

@Override
public LocalDate deserialize(JsonElement json, Type typeOfT,
                        JsonDeserializationContext context) throws JsonParseException {
    final String dateAsString = json.getAsString();
    final DateTimeFormatter dtf = DateTimeFormat.forPattern(DATE_FORMAT);
    if (dateAsString.length() == 0)
    {
        return null;
    }
    else
    {
        return dtf.parseLocalDate(dateAsString);
    }
}

@Override
public JsonElement serialize(LocalDate src, Type typeOfSrc,
                                                     JsonSerializationContext context) {
    String retVal;
    final DateTimeFormatter dtf = DateTimeFormat.forPattern(DATE_FORMAT);
    if (src == null)
    {
        retVal = "";
    }
    else
    {
        retVal = dtf.print(src);
    }
    return new JsonPrimitive(retVal);
}
}

Jetzt registrieren mit GsonBuilder:

final GsonBuilder builder = new GsonBuilder()
           .registerTypeAdapter(LocalDate.class, new My_DateSerializer());      
final Gson gson = builder.create();

InformationsquelleAutor Visakh

Spare ich einen tag mit meiner mongo-Dokument, die angibt, die dem ursprünglichen Typ des Objekts gespeichert. Ich habe dann mit Gson zu analysieren, es mit dem Namen des Typs. Zuerst erstellen Sie die gespeicherte Dokument

private static Gson gson = new Gson();

public static Document ConvertToDocument(Object rd) {
    if (rd instanceof Document)
        return (Document)rd;
    String json = gson.toJson(rd);
    Document doc = Document.parse(json); 
    doc.append(TYPE_FIELD, rd.getClass().getName());
    return doc;
}

dann zu Lesen das Dokument wieder in das Java -,

public static Object ConvertFromDocument(Document doc) throws CAAException {
    String clazzName = doc.getString(TYPE_FIELD);
    if (clazzName == null)
        throw new RuntimeException("Document was not stored in the DB or got stored without becing created by itemToStoredDocument()");
    Class<?> clazz;
    try {
        clazz = (Class<?>) Class.forName(clazzName);
    } catch (ClassNotFoundException e) {
        throw new CAAException("Could not load class " + clazzName, e);
    }

    json = com.mongodb.util.JSON.serialize(doc);
    return gson.fromJson(json, clazz);
}

Dank an Alexey für den Hinweis auf JSON.serialize().

InformationsquelleAutor David Wood

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.