Deserializzazione di un tipo generico con Jackson

Question

Sto cercando di creare una classe che utilizzi Jackson per deserializzare i POJO.

Sembra che questo ...

public class DeserialiserImp<T> implements Deserialiser<T> { 

     protected ObjectMapper objectMapper = new ObjectMapper(); 

     @Override 
     public T get(String content, Class clazz) throws IOException { 
      return (T) objectMapper.readValue(content, clazz); 
     } 

     @Override 
     public List<T> getList(String content, Class clazz) throws IOException { 
      return objectMapper.readValue(content, TypeFactory.collectionType(ArrayList.class, clazz)); 
     } 

    } 

Ho 2 domande su questa implementazione.

Il primo è che sto passando il tipo di classe nei metodi in modo che objectmapper conosca il tipo che dovrebbe deserializzare. C'è un modo migliore di usare i farmaci generici?

Anche nel metodo get sto trasmettendo un oggetto restituito da objectMapper a T. Questo sembra un modo particolarmente sgradevole di farlo in quanto devo lanciare T qui e poi devo anche lanciare il tipo di oggetto dal metodo che lo sta chiamando

Sto usando Roboguice in questo progetto quindi sarebbe bello se potessi cambiare il tipo tramite l'iniezione e quindi annotare l'oggetto di cui il tipo generico di cui ho bisogno per tornare. Ho letto su TypeLiteral e mi chiedevo se poteva risolvere questo problema?

Answer 1

Quindi penso di averlo capito alla fine. Per favore commenta se vedi qualcosa di sbagliato in quello che sto facendo.

L'interfaccia è definita in questo modo ...

public interface Deserialiser<T> { 

    T get(String content) throws IOException; 

    List<T> getList(String content) throws IOException; 
} 

L'implementazione dell'interfaccia è come questo ...

public class DeserialiserImp<T> implements Deserialiser<T> { 

    private ObjectMapper objectMapper = new ObjectMapper(); 
    private final Class<T> klass; 

    @Inject 
    public DeserialiserImp(TypeLiteral<T> type){ 
     this.klass = (Class<T>) type.getRawType(); 
    } 

    @Override 
    public T get(String content) throws IOException { 
     return objectMapper.readValue(content, klass); 
    } 

    @Override 
    public List<T> getList(String content) throws IOException { 
     return objectMapper.readValue(content, TypeFactory.collectionType(ArrayList.class, klass)); 
    } 

} 

Mi legano il 2 in questo modo ..

bind(new TypeLiteral<Deserialiser<User>>(){}).annotatedWith(Names.named("user")).to(new TypeLiteral<DeserialiserImp<User>>(){}); 

Poi tutto quello che devo fare per usarlo è questo ...

@Inject 
@Named("user") 
private Deserialiser<User> deserialiserImp; 

public void test(String userString) { 
    User user = deserialiserImp.get(UserString); 
} 

Questo modello potrebbe anche funzionare bene se la classe come una classe astratta da utilizzare in un oggetto DAO

This articolo mi ha aiutato

Answer 2

Il primo è che sto passando il tipo di classe nei metodi in modo che objectmapper conosca il tipo da deserializzare. C'è un modo migliore usando i farmaci generici?

Sfortunatamente no, e questo a causa della cancellazione del tipo.

Anche nel metodo get sto esprimono un oggetto restituito dal ObjectMapper a T. Ciò sembra particolarmente brutto modo di farlo, come ho dover lanciare T qui e poi devo lanciare anche il tipo di oggetto da il metodo che lo sta chiamando.

fare questo, invece:

@Override 
public T get(String content, Class<T> clazz) throws IOException { 
    return objectMapper.readValue(content, clazz); 
} 

Sto usando Roboguice in questo progetto quindi sarebbe bello se potessi modificare il tipo attraverso l'iniezione e quindi annotare l'oggetto il tipo generico Ne ho bisogno per tornare. Ho letto su TypeLiteral e chiedendomi se poteva risolvere questo problema?

Non capisco davvero cosa vuoi ottenere, ma dal momento che devi comunque passare la classe, è ancora possibile?