Conversion de JSon en plusieurs types d'objet Java inconnus à l'aide de GSon

Question

J'ai un netty decoder qui utilise GSon pour convertir JSon provenant d'un client Web en objets Java appropriés. La configuration requise est: Le client pourrait envoyer des classes sans rapport, Classe A, Classe B, Classe C, etc. mais je voudrais utiliser l'instance de décodeur même singleton dans le pipeline pour effectuer la conversion (puisque j'utilise spring pour le configurer). Le problème auquel je suis confronté est que j'ai besoin de connaître l'objet class avant la main.

public Object decode()
{
    gson.fromJson(jsonString, A.class);
}

Cela ne peut pas décoder B ou C. Les utilisateurs de ma bibliothèque ont maintenant besoin d'écrire des décodeurs séparés pour chaque classe au lieu d'une conversion ultérieure sur la ligne. Pour ce faire, la seule façon de procéder consiste à transmettre le nom de chaîne de la classe à "org.exemple.C" dans la chaîne JSon du client Web, à l'analyser dans le décodeur, puis à utiliser Class.forName pour obtenir la classe. Y a-t-il une meilleure manière de faire cela?

Answer 1

GSon DOIT connaître la classe correspondant à la chaîne JSON. Si vous ne voulez pas lui fournir fromJson (), vous pouvez le spécifier dans le Json. Une solution consiste à définir une interface et à lier un adaptateur dessus.

Comme :

  class A implements MyInterface {
    // ...
  }

  public Object decode()
  {
    Gson  gson = builder.registerTypeAdapter(MyInterface.class, new MyInterfaceAdapter());
    MyInterface a =  gson.fromJson(jsonString, MyInterface.class);
  }

L'adaptateur peut être comme:

public final class MYInterfaceAdapter implements JsonDeserializer<MyInterface>, JsonSerializer<MyInterface> {
  private static final String PROP_NAME = "myClass";

  @Override
  public MyInterface deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
    try {
      String classPath = json.getAsJsonObject().getAsJsonPrimitive(PROP_NAME).getAsString();
      Class<MyInterface> cls = (Class<MyInterface>) Class.forName(classPath);

      return (MyInterface) context.deserialize(json, cls);
    } catch (ClassNotFoundException e) {
      e.printStackTrace();
    }

    return null;
  }

  @Override
  public JsonElement serialize(MyInterface src, Type typeOfSrc, JsonSerializationContext context) {
    // note : won't work, you must delegate this
    JsonObject jo = context.serialize(src).getAsJsonObject();

    String classPath = src.getClass().getName();
    jo.add(PROP_NAME, new JsonPrimitive(classPath));

    return jo;
  }
}

Answer 2

Supposons que vous ayez ces 2 réponses JSON possibles:

{
  "classA": {"foo": "fooValue"}
}
  or
{
  "classB": {"bar": "barValue"}
}

Vous pouvez créer une structure de classe comme ceci:

public class Response {
  private A classA;
  private B classB;
  //more possible responses...
  //getters and setters...
}

public class A {
  private String foo;
  //getters and setters...
}

public class B {
  private String bar;
  //getters and setters...
}

Ensuite, vous pouvez analyser n’importe laquelle des réponses JSON possibles avec:

Response response = gson.fromJson(jsonString, Response.class);

Gson ignorera tous les champs JSON qui ne correspondent à aucun des attributs de votre structure de classe. Vous pouvez donc adapter une seule classe à l'analyse de différentes réponses ...

Ensuite, vous pourrez vérifier lequel des attributs classA, classB, ... n'est pas null et vous saurez quelle réponse vous avez reçue.

Answer 3

Vous ne savez pas si c'est ce que vous demandiez, mais en modifiant la classe RuntimeTypeAdapterFactory, j'ai créé un système de sous-classement basé sur les conditions de la source Json. RuntimeTypeAdapterFactory.class:

/*
 * Copyright (C) 2011 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.Apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.gson.typeadapters;

import Java.io.IOException;
import Java.util.LinkedHashMap;
import Java.util.Map;

import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.google.gson.JsonPrimitive;
import com.google.gson.TypeAdapter;
import com.google.gson.TypeAdapterFactory;
import com.google.gson.internal.Streams;
import com.google.gson.reflect.TypeToken;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonWriter;

/**
 * Adapts values whose runtime type may differ from their declaration type. This
 * is necessary when a field's type is not the same type that GSON should create
 * when deserializing that field. For example, consider these types:
 * <pre>   {@code
 *   abstract class Shape {
 *     int x;
 *     int y;
 *   }
 *   class Circle extends Shape {
 *     int radius;
 *   }
 *   class Rectangle extends Shape {
 *     int width;
 *     int height;
 *   }
 *   class Diamond extends Shape {
 *     int width;
 *     int height;
 *   }
 *   class Drawing {
 *     Shape bottomShape;
 *     Shape topShape;
 *   }
 * }</pre>
 * <p>Without additional type information, the serialized JSON is ambiguous. Is
 * the bottom shape in this drawing a rectangle or a diamond? <pre>   {@code
 *   {
 *     "bottomShape": {
 *       "width": 10,
 *       "height": 5,
 *       "x": 0,
 *       "y": 0
 *     },
 *     "topShape": {
 *       "radius": 2,
 *       "x": 4,
 *       "y": 1
 *     }
 *   }}</pre>
 * This class addresses this problem by adding type information to the
 * serialized JSON and honoring that type information when the JSON is
 * deserialized: <pre>   {@code
 *   {
 *     "bottomShape": {
 *       "type": "Diamond",
 *       "width": 10,
 *       "height": 5,
 *       "x": 0,
 *       "y": 0
 *     },
 *     "topShape": {
 *       "type": "Circle",
 *       "radius": 2,
 *       "x": 4,
 *       "y": 1
 *     }
 *   }}</pre>
 * Both the type field name ({@code "type"}) and the type labels ({@code
 * "Rectangle"}) are configurable.
 *
 * <h3>Registering Types</h3>
 * Create a {@code RuntimeTypeAdapter} by passing the base type and type field
 * name to the {@link #of} factory method. If you don't supply an explicit type
 * field name, {@code "type"} will be used. <pre>   {@code
 *   RuntimeTypeAdapter<Shape> shapeAdapter
 *       = RuntimeTypeAdapter.of(Shape.class, "type");
 * }</pre>
 * Next register all of your subtypes. Every subtype must be explicitly
 * registered. This protects your application from injection attacks. If you
 * don't supply an explicit type label, the type's simple name will be used.
 * <pre>   {@code
 *   shapeAdapter.registerSubtype(Rectangle.class, "Rectangle");
 *   shapeAdapter.registerSubtype(Circle.class, "Circle");
 *   shapeAdapter.registerSubtype(Diamond.class, "Diamond");
 * }</pre>
 * Finally, register the type adapter in your application's GSON builder:
 * <pre>   {@code
 *   Gson gson = new GsonBuilder()
 *       .registerTypeAdapter(Shape.class, shapeAdapter)
 *       .create();
 * }</pre>
 * Like {@code GsonBuilder}, this API supports chaining: <pre>   {@code
 *   RuntimeTypeAdapter<Shape> shapeAdapter = RuntimeTypeAdapterFactory.of(Shape.class)
 *       .registerSubtype(Rectangle.class)
 *       .registerSubtype(Circle.class)
 *       .registerSubtype(Diamond.class);
 * }</pre>
 */
public final class RuntimeTypeAdapterFactory<T> implements TypeAdapterFactory {
    private final Class<?> baseType;
    private final RuntimeTypeAdapterPredicate predicate;
    private final Map<String, Class<?>> labelToSubtype = new LinkedHashMap<String, Class<?>>();
    private final Map<Class<?>, String> subtypeToLabel = new LinkedHashMap<Class<?>, String>();

    private RuntimeTypeAdapterFactory(Class<?> baseType, RuntimeTypeAdapterPredicate predicate) {
        if (predicate == null || baseType == null) {
            throw new NullPointerException();
        }
        this.baseType = baseType;
        this.predicate = predicate;
    }

    /**
     * Creates a new runtime type adapter using for {@code baseType} using {@code
     * typeFieldName} as the type field name. Type field names are case sensitive.
     */
    public static <T> RuntimeTypeAdapterFactory<T> of(Class<T> baseType, RuntimeTypeAdapterPredicate predicate) {
        return new RuntimeTypeAdapterFactory<T>(baseType, predicate);
    }

    /**
     * Creates a new runtime type adapter for {@code baseType} using {@code "type"} as
     * the type field name.
     */
    public static <T> RuntimeTypeAdapterFactory<T> of(Class<T> baseType) {
        return new RuntimeTypeAdapterFactory<T>(baseType, null);
    }

    /**
     * Registers {@code type} identified by {@code label}. Labels are case
     * sensitive.
     *
     * @throws IllegalArgumentException if either {@code type} or {@code label}
     *     have already been registered on this type adapter.
     */
    public RuntimeTypeAdapterFactory<T> registerSubtype(Class<? extends T> type, String label) {
        if (type == null || label == null) {
            throw new NullPointerException();
        }
        if (subtypeToLabel.containsKey(type) || labelToSubtype.containsKey(label)) {
            throw new IllegalArgumentException("types and labels must be unique");
        }
        labelToSubtype.put(label, type);
        subtypeToLabel.put(type, label);
        return this;
    }

    /**
     * Registers {@code type} identified by its {@link Class#getSimpleName simple
     * name}. Labels are case sensitive.
     *
     * @throws IllegalArgumentException if either {@code type} or its simple name
     *     have already been registered on this type adapter.
     */
    public RuntimeTypeAdapterFactory<T> registerSubtype(Class<? extends T> type) {
        return registerSubtype(type, type.getSimpleName());
    }

    public <R> TypeAdapter<R> create(Gson gson, TypeToken<R> type) {
        if (type.getRawType() != baseType) {
            return null;
        }

        final Map<String, TypeAdapter<?>> labelToDelegate
                = new LinkedHashMap<String, TypeAdapter<?>>();
        final Map<Class<?>, TypeAdapter<?>> subtypeToDelegate
                = new LinkedHashMap<Class<?>, TypeAdapter<?>>();
        for (Map.Entry<String, Class<?>> entry : labelToSubtype.entrySet()) {
            TypeAdapter<?> delegate = gson.getDelegateAdapter(this, TypeToken.get(entry.getValue()));
            labelToDelegate.put(entry.getKey(), delegate);
            subtypeToDelegate.put(entry.getValue(), delegate);
        }

        return new TypeAdapter<R>() {
            @Override public R read(JsonReader in) throws IOException {
                JsonElement jsonElement = Streams.parse(in);
                String label = predicate.process(jsonElement);
                @SuppressWarnings("unchecked") // registration requires that subtype extends T
                        TypeAdapter<R> delegate = (TypeAdapter<R>) labelToDelegate.get(label);
                if (delegate == null) {
                    throw new JsonParseException("cannot deserialize " + baseType + " subtype named "
                            + label + "; did you forget to register a subtype?");
                }
                return delegate.fromJsonTree(jsonElement);
            }

            @Override public void write(JsonWriter out, R value) throws IOException { // Unimplemented as we don't use write.
                /*Class<?> srcType = value.getClass();
                String label = subtypeToLabel.get(srcType);
                @SuppressWarnings("unchecked") // registration requires that subtype extends T
                        TypeAdapter<R> delegate = (TypeAdapter<R>) subtypeToDelegate.get(srcType);
                if (delegate == null) {
                    throw new JsonParseException("cannot serialize " + srcType.getName()
                            + "; did you forget to register a subtype?");
                }
                JsonObject jsonObject = delegate.toJsonTree(value).getAsJsonObject();
                if (jsonObject.has(typeFieldName)) {
                    throw new JsonParseException("cannot serialize " + srcType.getName()
                            + " because it already defines a field named " + typeFieldName);
                }
                JsonObject clone = new JsonObject();
                clone.add(typeFieldName, new JsonPrimitive(label));
                for (Map.Entry<String, JsonElement> e : jsonObject.entrySet()) {
                    clone.add(e.getKey(), e.getValue());
                }*/
                Streams.write(null, out);
            }
        };
    }
}

RuntimeTypeAdapterPredicate.class:

package com.google.gson.typeadapters;

import com.google.gson.JsonElement;

/**
 * Created by Johan on 2014-02-13.
 */
public abstract class RuntimeTypeAdapterPredicate {

    public abstract String process(JsonElement element);

}

Exemple (tiré d'un projet sur lequel je travaille actuellement):

ItemTypePredicate.class:

package org.libpoe.serial;

import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.typeadapters.RuntimeTypeAdapterPredicate;

/**
 * Created by Johan on 2014-02-13.
 */
public class ItemTypePredicate extends RuntimeTypeAdapterPredicate {

    @Override
    public String process(JsonElement element) {
        JsonObject obj = element.getAsJsonObject();
        int frameType = obj.get("frameType").getAsInt();

        switch(frameType) {
            case 4: return "Gem";
            case 5: return "Currency";
        }
        if (obj.get("typeLine").getAsString().contains("Map")
                && obj.get("descrText").getAsString() != null
                && obj.get("descrText").getAsString().contains("Travel to this Map")) {
            return "Map";
        }

        return "Equipment";
    }
}

Usage:

RuntimeTypeAdapterFactory<Item> itemAdapter = RuntimeTypeAdapterFactory.of(Item.class, new ItemTypePredicate())
        .registerSubtype(Currency.class)
        .registerSubtype(Equipment.class)
        .registerSubtype(Gem.class)
        .registerSubtype(Map.class);

Gson gson = new GsonBuilder()
        .enableComplexMapKeySerialization()
        .registerTypeAdapterFactory(itemAdapter).create();

La classe de base de la hiérarchie est Item. La monnaie, l'équipement, la gemme et la carte étendent tous cela.

Answer 4

Créer une classe de modèle,

public class MyModel {

    private String errorId;

    public String getErrorId() {
        return errorId;
    }

    public void setErrorId(String errorId) {
        this.errorId = errorId;
    }
}

Créer une sous-classe

   public class SubClass extends MyModel {
        private String subString;

       public String getSubString() {
            return subString;
        }

        public void setSubString(String subString) {
            this.subString = subString;
        }
 }

appelez la méthode parseGson

parseGson(subClass);

méthode d'analyse gson avec une classe d'objet

   public void parseGson(Object object){
     object = gson.fromJson(response.toString(), object.getClass());
     SubClass subclass = (SubClass)object;
   }

Vous pouvez définir des variables globales transtypées vers myModel.

((MyModel)object).setErrorId(response.getString("errorid"));