Deserialisieren eines generischen Typs mit Jackson

Question

Ich versuche, eine Klasse zu machen, die den Jackson verwendet, um POJOs zu deserialisieren.

Es sieht wie folgt aus ...

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

    } 

Ich habe 2 Fragen zu dieser Umsetzung.

Die erste besteht darin, dass ich den Klassentyp in die Methoden übergebe, damit der Objektmapper den Typ kennt, der deserialisiert werden sollte. Gibt es einen besseren Weg, Generika zu verwenden?

Auch in der Get-Methode bin ich ein Objekt vom ObjektMapper zu T geworfen. Dies scheint besonders fiese Art und Weise es zu tun, wie ich T hier werfen muss und dann muss ich auch den Objekttyp aus der Methode, die ruft es an.

Ich benutze Roboguice in diesem Projekt, so wäre es nett, wenn ich den Typ durch Injektion ändern und dann das Objekt mit dem generischen Typ kommentieren könnte, den ich es zurückgeben muss. Ich lese über TypeLiteral und frage mich, ob es dieses Problem lösen könnte?

Answer 1

Also ich denke, ich habe es am Ende herausgefunden. Bitte kommentiere, wenn du etwas falsch machst mit dem was ich tue.

Die Schnittstelle wie so definiert ist ...

public interface Deserialiser<T> { 

    T get(String content) throws IOException; 

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

Die Implementierung der Schnittstelle wie das ist ...

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

} 

Ich binde das 2 wie so ..

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

Dann alles, was ich tun müssen, um es zu benutzen ist dies ...

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

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

Dieses Muster auch gut funktionieren könnte, wenn die Klasse als abstrakte Klasse in einem DAO-Objekt verwenden

This Artikel hat mir geholfen

Answer 2

Die erste besteht darin, dass ich den Klassentyp in die Methoden übergebe, so dass der Objektmapper den Typ kennt, der deserialisiert werden sollte. Gibt es einen besseren Weg mit Generika?

Leider nicht, und dies ist wegen Typ löschen.

Auch in der get-Methode mir ein Objekt aus dem Dies scheint besonders perfide Art und Weise, es zu tun, wie ich habe zu werfen T hier und dann auch objectMapper T. am Casting zurück geworfen Ich muß den Objekttyp von die Methode, die es aufruft.

Tun Sie dies statt:

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

Ich verwende Roboguice in diesem Projekt so wäre es schön, wenn ich die Art durch Injektion ändern könnte und dann mit Anmerkungen versehen das Objekt, das der generische Typ Ich muss es zurückgeben. Ich habe über TypeLiteral und gelesen und frage mich, ob es dieses Problem lösen könnte?

Ich verstehe nicht wirklich, was Sie erreichen wollen, aber da Sie die Klasse sowieso bestehen müssen, ist das noch möglich?