para que sirve settitle en java

Jackson y referencia de tipo genérico

Question

Quiero usar la biblioteca de jackson json para un método genérico de la siguiente manera:

public MyRequest<T> tester(){
  TypeReference<MyWrapper<T>> typeRef = new TypeReference<MyWrapper<T>>();  
  MyWrapper<T> requestWrapper = (MyWrapper<T>) JsonConverter.fromJson(jsonRequest, typeRef);
  return requestWrapper.getRequest();
}

public class MyWrapper<T> {

    private MyRequest<T> request;

    public MyRequest<T> getRequest() {
        return request;
    }

    public void setRequest(MyRequest<T> request) {
        this.request = request;
    }
}


 public class MyRequest{
     private List<T> myobjects;

     public void setMyObjects(List<T> ets) {
         this.myobjects = ets;
     }

     @NotNull
     @JsonIgnore
     public T getMyObject() {
         return myobjects.get(0);
     }
}

Ahora el problema es que cuando llamo getMyObject () que está dentro del objeto de solicitud, jackson devuelve el objeto personalizado anidado como LinkedHashMap. ¿Hay alguna manera en que especifique que el objeto T necesita ser devuelto? Por ejemplo: si envié un objeto de tipo Cliente, entonces el Cliente debería ser devuelto desde esa Lista.

Gracias.

Answer 1

''JavaType'' funciona !! Estaba tratando de deshacer (deserializar) una Lista en json String to ArrayList java Objects y estaba luchando por encontrar una solución desde hace días.
A continuación está el código que finalmente me dio solución. Código:

JsonMarshallerUnmarshaller<T> {
    T targetClass;

    public ArrayList<T> unmarshal(String jsonString) {
        ObjectMapper mapper = new ObjectMapper();

        AnnotationIntrospector introspector = new JacksonAnnotationIntrospector();
        mapper.getDeserializationConfig()
            .withAnnotationIntrospector(introspector);

        mapper.getSerializationConfig()
            .withAnnotationIntrospector(introspector);
        JavaType type = mapper.getTypeFactory().
            constructCollectionType(
                ArrayList.class, 
                targetclass.getClass());

        try {
            Class c1 = this.targetclass.getClass();
            Class c2 = this.targetclass1.getClass();
            ArrayList<T> temp = (ArrayList<T>) 
                mapper.readValue(jsonString,  type);
            return temp ;
        } catch (JsonParseException e) {
            e.printStackTrace();
        } catch (JsonMappingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null ;
    }  
}

Answer 2

Este es un problema bien conocido con el borrado de tipo Java: T es solo una variable de tipo, y debe indicar la clase real, generalmente como argumento de Clase. Sin dicha información, lo mejor que se puede hacer es usar límites; y plain T es más o menos lo mismo que ''T extends Object''. Y Jackson enlazará JSON Objects como Maps.

En este caso, el método de prueba debe tener acceso a Clase, y puede construir

JavaType type = mapper.getTypeFactory().
  constructCollectionType(List.class, Foo.class)

y entonces

List<Foo> list = mapper.readValue(new File("input.json"), type);