Sollte ich Jacksons ObjectMapper als statisches Feld deklarieren?

Die ObjectMapperKlasse der Jackson-Bibliothek scheint threadsicher zu sein .

Bedeutet dies, dass ich mein ObjectMapperFeld als solches statisch deklarieren sollte?

class Me {
    private static final ObjectMapper mapper = new ObjectMapper();
}

statt als solches Feld auf Instanzebene?

class Me {
    private final ObjectMapper mapper = new ObjectMapper();
}

Ja, das ist sicher und empfohlen.

Die einzige Einschränkung auf der Seite, auf die Sie verwiesen haben, ist, dass Sie die Konfiguration des Mappers nicht mehr ändern können, sobald er freigegeben ist. Sie ändern jedoch nicht die Konfiguration, sodass dies in Ordnung ist. Wenn Sie die Konfiguration ändern müssten, würden Sie dies über den statischen Block tun, und es wäre auch in Ordnung.

EDIT : (2013/10)

Ab 2.0 kann das oben Gesagte erweitert werden, indem festgestellt wird, dass es einen noch besseren Weg gibt: Verwendung ObjectWriterund ObjectReaderObjekte, die von konstruiert werden können ObjectMapper. Sie sind vollständig unveränderlich, threadsicher, was bedeutet, dass es theoretisch nicht einmal möglich ist, Thread-Sicherheitsprobleme zu verursachen (die auftreten können, ObjectMapperwenn Code versucht, die Instanz neu zu konfigurieren).

Obwohl ObjectMapper threadsicher ist, würde ich dringend davon abraten, es als statische Variable zu deklarieren, insbesondere in Multithread-Anwendungen. Nicht einmal, weil es eine schlechte Praxis ist, sondern weil Sie ein hohes Risiko eines Deadlocks haben. Ich erzähle es aus meiner eigenen Erfahrung. Ich habe eine Anwendung mit 4 identischen Threads erstellt, die JSON-Daten von Webdiensten abrufen und verarbeiten. Meine Anwendung wurde laut Thread-Dump häufig mit dem folgenden Befehl blockiert:

Map aPage = mapper.readValue(reader, Map.class);

Außerdem war die Leistung nicht gut. Als ich die statische Variable durch die instanzbasierte Variable ersetzte, verschwand das Abwürgen und die Leistung vervierfachte sich. Dh 2,4 Millionen JSON-Dokumente wurden in 40 Minuten, 56 Sekunden anstatt 2,5 Stunden zuvor verarbeitet.

Obwohl es sicher ist, einen statischen ObjectMapper im Hinblick auf die Thread-Sicherheit zu deklarieren, sollten Sie sich bewusst sein, dass das Erstellen statischer Objektvariablen in Java als schlechte Praxis angesehen wird. Weitere Informationen finden Sie unter Warum werden statische Variablen als böse angesehen? (und wenn Sie möchten, meine Antwort )

Kurz gesagt, Statik sollte vermieden werden, da dies das Schreiben präziser Komponententests erschwert. Beispielsweise können Sie mit einem statischen endgültigen ObjectMapper die JSON-Serialisierung nicht gegen Dummy-Code oder ein No-Op austauschen.

Darüber hinaus verhindert ein statisches Finale, dass Sie ObjectMapper zur Laufzeit neu konfigurieren können. Sie können sich jetzt vielleicht keinen Grund dafür vorstellen, aber wenn Sie sich in ein statisches endgültiges Muster einschließen, können Sie es durch Herunterfahren des Klassenladeprogramms neu initialisieren.

Im Fall von ObjectMapper ist es in Ordnung, aber im Allgemeinen ist es eine schlechte Praxis und es gibt keinen Vorteil gegenüber der Verwendung eines Singleton-Musters oder einer Umkehrung der Kontrolle, um Ihre langlebigen Objekte zu verwalten.

Ein Trick, den ich aus dieser PR gelernt habe, wenn Sie sie nicht als statische Endvariable definieren, sondern ein wenig Overhead sparen und Thread-Sicherheit gewährleisten möchten.

private static final ThreadLocal<ObjectMapper> om = new ThreadLocal<ObjectMapper>() {
    @Override
    protected ObjectMapper initialValue() {
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        return objectMapper;
    }
};

public static ObjectMapper getObjectMapper() {
    return om.get();
}

Gutschrift an den Autor.

com.fasterxml.jackson.databind.type.TypeFactory._hashMapSuperInterfaceChain (HierarchicType)

com.fasterxml.jackson.databind.type.TypeFactory._findSuperInterfaceChain(Type, Class)
  com.fasterxml.jackson.databind.type.TypeFactory._findSuperTypeChain(Class, Class)
     com.fasterxml.jackson.databind.type.TypeFactory.findTypeParameters(Class, Class, TypeBindings)
        com.fasterxml.jackson.databind.type.TypeFactory.findTypeParameters(JavaType, Class)
           com.fasterxml.jackson.databind.type.TypeFactory._fromParamType(ParameterizedType, TypeBindings)
              com.fasterxml.jackson.databind.type.TypeFactory._constructType(Type, TypeBindings)
                 com.fasterxml.jackson.databind.type.TypeFactory.constructType(TypeReference)
                    com.fasterxml.jackson.databind.ObjectMapper.convertValue(Object, TypeReference)

Die Methode _hashMapSuperInterfaceChain in der Klasse com.fasterxml.jackson.databind.type.TypeFactory wird synchronisiert. Ich sehe Streit um das gleiche bei hohen Lasten.

Kann ein weiterer Grund sein, einen statischen ObjectMapper zu vermeiden