Devo dichiarare ObjectMapper di Jackson come un campo statico?

La ObjectMapperclasse della biblioteca di Jackson sembra essere thread-safe .

Questo significa che dovrei dichiarare il mio ObjectMappercampo statico come questo

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

anziché come un campo a livello di istanza come questo?

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

Sì, è sicuro e consigliato.

L'unico avvertimento dalla pagina che hai indicato è che non puoi modificare la configurazione del mapper una volta condiviso; ma non stai modificando la configurazione, quindi va bene. Se fosse necessario modificare la configurazione, lo si farebbe dal blocco statico e andrebbe anche bene.

EDIT : (2013/10)

Con 2.0 e versioni successive, le versioni precedenti possono essere aumentate osservando che esiste un modo ancora migliore: uso ObjectWritere ObjectReaderoggetti, che possono essere costruiti da ObjectMapper. Sono completamente immutabili, sicuri per i thread, il che significa che teoricamente non è nemmeno possibile causare problemi di sicurezza dei thread (che possono verificarsi ObjectMapperse il codice tenta di riconfigurare l'istanza).

Sebbene ObjectMapper sia thread-safe, scoraggerei fortemente dal dichiararlo come variabile statica, specialmente in applicazioni multithread. Neanche perché è una cattiva pratica, ma perché stai correndo un grosso rischio di deadlock. Lo dico per esperienza personale. Ho creato un'applicazione con 4 thread identici che stavano ottenendo ed elaborando i dati JSON dai servizi web. La mia applicazione era spesso bloccata sul seguente comando, secondo il dump del thread:

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

Inoltre, le prestazioni non erano buone. Quando ho sostituito la variabile statica con la variabile basata sull'istanza, lo stallo è scomparso e le prestazioni sono quadruplicate. Vale a dire 2,4 milioni di documenti JSON sono stati elaborati in 40 minuti e 56 secondi, anziché 2,5 ore prima.

Sebbene sia sicuro dichiarare un ObjectMapper statico in termini di sicurezza dei thread, è necessario tenere presente che la costruzione di variabili statiche di oggetti in Java è considerata una cattiva pratica. Per maggiori dettagli, vedi Perché le variabili statiche sono considerate malvagie? (e se vuoi, la mia risposta )

In breve, la statica dovrebbe essere evitata perché rende difficile scrivere test unitari concisi. Ad esempio, con un ObjectMapper finale statico, non è possibile scambiare la serializzazione JSON con codice fittizio o no-op.

Inoltre, un finale statico ti impedisce di riconfigurare ObjectMapper in fase di esecuzione. Potresti non immaginare un motivo per questo ora, ma se ti blocchi in uno schema finale statico, nientemeno che abbattere il classloader ti permetterà di reinizializzarlo.

Nel caso di ObjectMapper va bene, ma in generale è una cattiva pratica e non vi è alcun vantaggio rispetto all'utilizzo di un modello singleton o inversione di controllo per gestire i tuoi oggetti di lunga durata.

Un trucco che ho imparato da questo PR se non vuoi definirlo come variabile finale statica ma vuoi risparmiare un po 'di overhead e garantire thread thread safe.

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();
}

merito all'autore.

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)

Il metodo _hashMapSuperInterfaceChain nella classe com.fasterxml.jackson.databind.type.TypeFactory è sincronizzato. Sto vedendo contesa sullo stesso a carichi elevati.

Potrebbe essere un altro motivo per evitare un ObjectMapper statico