Jackson - Désérialiser à l'aide d'une classe générique

J'ai une chaîne json, que je devrais désérialiser dans la classe suivante

class Data <T> {
    int found;
    Class<T> hits
}

Comment fait-on ça? C'est la manière habituelle

mapper.readValue(jsonString, Data.class);

Mais comment mentionner ce que signifie T?

Vous devez créer un TypeReferenceobjet pour chaque type générique que vous utilisez et l'utiliser pour la désérialisation. Par exemple -

mapper.readValue(jsonString, new TypeReference<Data<String>>() {});

Vous ne pouvez pas faire cela: vous devez spécifier un type entièrement résolu, comme Data<MyType>. Test juste une variable, et comme cela n'a pas de sens.

Mais si vous voulez dire que Tcela sera connu, mais pas de manière statique, vous devez créer l'équivalent de TypeReferencedynamiquement. D'autres questions référencées peuvent déjà le mentionner, mais cela devrait ressembler à quelque chose comme:

public Data<T> read(InputStream json, Class<T> contentClass) {
   JavaType type = mapper.getTypeFactory().constructParametricType(Data.class, contentClass);
   return mapper.readValue(json, type);
}

La première chose à faire est de sérialiser, puis de désérialiser.
Ainsi, lorsque vous sérialisez, vous devez utiliser @JsonTypeInfopour laisser jackson écrire les informations de classe dans vos données json. Voici ce que vous pouvez faire:

Class Data <T> {
    int found;
    @JsonTypeInfo(use=JsonTypeInfo.Id.CLASS, include=JsonTypeInfo.As.PROPERTY, property="@class")
    Class<T> hits
}

Ensuite, lorsque vous désérialisez, vous constaterez que jackson a désérialisé vos données dans une classe que votre variable atteint réellement lors de l'exécution.

Pour les données de classe <>

ObjectMapper mapper = new ObjectMapper();
JavaType type = mapper.getTypeFactory().constructParametrizedType(Data.class, Data.class, Parameter.class);
Data<Parameter> dataParam = mapper.readValue(jsonString,type)

Écrivez simplement une méthode statique dans la classe Util. Je lis un Json à partir d'un fichier. vous pouvez également donner String à readValue

public static <T> T convertJsonToPOJO(String filePath, Class<?> target) throws JsonParseException, JsonMappingException, IOException, ClassNotFoundException {
        ObjectMapper objectMapper = new ObjectMapper();
        return objectMapper.readValue(new File(filePath), objectMapper .getTypeFactory().constructCollectionType(List.class, Class.forName(target.getName())));
}

Usage:

List<TaskBean> list =  Util.<List<TaskBean>>convertJsonToPOJO("E:/J2eeWorkspaces/az_workspace_svn/az-client-service/dir1/dir2/filename.json", TaskBean.class);

Vous pouvez l'envelopper dans une autre classe qui connaît le type de votre type générique.

Par exemple,

class Wrapper {
 private Data<Something> data;
}
mapper.readValue(jsonString, Wrapper.class);

Ici, quelque chose est un type concret. Vous avez besoin d'un wrapper par type réifié. Sinon, Jackson ne sait pas quels objets créer.

La chaîne JSON qui doit être désérialisée devra contenir les informations de type sur le paramètre T.
Vous devrez mettre des annotations Jackson sur chaque classe qui peut être transmise en tant que paramètre Tà la classe Dataafin que les informations de type sur le type de paramètre Tpuissent être lues / écrites dans la chaîne JSON par Jackson.

Supposons que cela Tpuisse être n'importe quelle classe qui étend une classe abstraite Result.

class Data <T extends Result> {
    int found;
    Class<T> hits
}

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.WRAPPER_OBJECT)
@JsonSubTypes({
        @JsonSubTypes.Type(value = ImageResult.class, name = "ImageResult"),
        @JsonSubTypes.Type(value = NewsResult.class, name = "NewsResult")})
public abstract class Result {

}

public class ImageResult extends Result {

}

public class NewsResult extends Result {

}

Une fois que chacune des classes (ou leur supertype commun) qui peut être transmise en tant que paramètre T est annotée, Jackson inclura des informations sur le paramètre Tdans le JSON. Un tel JSON peut ensuite être désérialisé sans connaître le paramètre Tau moment de la compilation.
Ce lien de documentation Jackson parle de la désérialisation polymorphe, mais il est également utile de s'y référer pour cette question.

Depuis Jackson 2.5, une manière élégante de résoudre cela utilise la méthode TypeFactory.constructParametricType (Class parametrized, Class ... parameterClasses) qui permet de définir directement un Jackson JavaTypeen spécifiant la classe paramétrée et ses types paramétrés.

En supposant que vous souhaitiez désérialiser vers Data<String>, vous pouvez faire:

// the json variable may be a String, an InputStream and so for...
JavaType type = mapper.getTypeFactory().constructParametricType(Data.class, String.class);
Data<String> data = mapper.readValue(json, type);

Notez que si la classe déclarait plusieurs types paramétrés, ce ne serait pas vraiment plus difficile:

class Data <T, U> {
    int found;
    Class<T> hits;
    List<U> list;
}

Nous pourrions faire :

JavaType type = mapper.getTypeFactory().constructParametricType(Data.class, String.class, Integer);
Data<String, Integer> data = mapper.readValue(json, type);

public class Data<T> extends JsonDeserializer implements ContextualDeserializer {
    private Class<T> cls;
    public JsonDeserializer createContextual(DeserializationContext ctx, BeanProperty prop) throws JsonMappingException {
        cls = (Class<T>) ctx.getContextualType().getRawClass();
        return this;
    }
    ...
 }

si vous utilisez scala et connaissez le type générique au moment de la compilation, mais que vous ne voulez pas passer manuellement TypeReference partout dans tous vos api l ayers, vous pouvez utiliser le code suivant (avec jackson 2.9.5):

def read[T](entityStream: InputStream)(implicit typeTag: WeakTypeTag[T]): T = {

    //nathang: all of this *crazy* scala reflection allows us to handle List[Seq[Map[Int,Value]]]] without passing
    // new TypeReference[List[Seq[Map[Int,Value]]]]](){} to the function

    def recursiveFindGenericClasses(t: Type): JavaType = {
      val current = typeTag.mirror.runtimeClass(t)

      if (t.typeArgs.isEmpty) {
        val noSubtypes = Seq.empty[Class[_]]
        factory.constructParametricType(current, noSubtypes:_*)
      }

      else {
        val genericSubtypes: Seq[JavaType] = t.typeArgs.map(recursiveFindGenericClasses)
        factory.constructParametricType(current, genericSubtypes:_*)
      }

    }

    val javaType = recursiveFindGenericClasses(typeTag.tpe)

    json.readValue[T](entityStream, javaType)
  }

qui peut être utilisé comme ceci:

read[List[Map[Int, SomethingToSerialize]]](inputStream)

Pour désérialiser une chaîne JSON générique en objet Java avec Jackson, vous avez besoin de:

1. Pour définir une classe JSON.

2. Effectuez un mappage d'attributs.

Code final, testé et prêt à être utilisé:

static class MyJSON {

    private Map<String, Object> content = new HashMap<>();

    @JsonAnySetter
    public void setContent(String key, Object value) {
        content.put(key, value);
    }
}

String json = "{\"City\":\"Prague\"}";

try {

    MyPOJO myPOJO = objectMapper.readValue(json, MyPOJO.class);

    String jsonAttVal = myPOJO.content.get("City").toString();

    System.out.println(jsonAttVal);

} catch (IOException e) {
    e.printStackTrace();
}

Important: l'
@JsonAnySetter annotation est obligatoire, elle garantit une analyse et un peuplement JSON génériques.

Pour les cas plus compliqués avec des tableaux imbriqués, veuillez consulter la référence Baeldung: https://www.baeldung.com/jackson-mapping-dynamic-object

Exemple de décision pas très bonne, mais simple (pas seulement pour Jackson, également pour Spring RestTemplate, etc.):

Set<MyClass> res = new HashSet<>();
objectMapper.readValue(json, res.getClass());