2013-06-11 13 views
13

Ich habe einen Nettodecoder, der GSon verwendet, um JSon, das vom Webclient stammt, in geeignete Java-Objekte zu konvertieren. Die Anforderung ist: Client könnte nicht verwandte Klassen, Klasse A, Klasse B, Klasse C usw. senden, aber ich würde gerne die selbe singleton Decoder-Instanz in der Pipeline verwenden, um die Konvertierung zu tun (da ich Feder für die Konfiguration verwenden) . Das Problem, mit dem ich konfrontiert bin, ist, dass ich das class Objekt vor der Hand kennen muss.Konvertieren von JSon in mehrere unbekannte Java-Objekttypen mit GSon

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

Dies kann nicht B oder C. dekodieren Die Nutzer von meiner Bibliothek, müssen nun getrennte Decoder für jede Klasse anstelle eines Guss später auf der ganzen Linie schreiben. Der einzige Weg, dies zu sehen, ist, den String-Namen der Klasse say "org.example.C" in der JSon-Zeichenfolge vom Webclient zu übergeben, im Decoder zu analysieren und dann Class.forName zu verwenden, um die Klasse zu erhalten. Gibt es einen besseren Weg, dies zu tun?

+2

Wenn dies eine Allzweck-Komponente, darüber nachzudenken, wie Sie Ihre Benutzer konfigurieren wollen. Sinnvolle Vorgaben sind es auch wert, darüber nachzudenken. Wäre es sinnvoll, mehrere Decoder-Instanzen zu haben, eine pro Klasse? – Jukka

+0

So mache ich das derzeit, eine Instanz pro Klassenart. Problem ist, dass Benutzer meiner Bibliothek jetzt interne Details wie Decoder und Encoder tun müssen und sie jedes Mal im Frühling konfigurieren müssen, wenn eine neue Klasse hinzugefügt wird. Ich wollte ihnen das ersparen und stattdessen eine einfache Besetzung machen. – Abe

Antwort

10

GSon muss die Klasse kennen, die der JSON-Zeichenfolge entspricht. Wenn Sie es nicht mit fromJson() bereitstellen möchten, können Sie es in Json angeben. Eine Möglichkeit besteht darin, eine Schnittstelle zu definieren und einen Adapter darauf zu binden.

Like:

class A implements MyInterface { 
    // ... 
    } 

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

Adapter kann wie:

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; 
    } 
} 
+0

Das Problem hier ist, dass Klasse B "MyInterface" nicht implementieren würde. Dies sind keine logisch verknüpften Klassen. Aber wahrscheinlich muss ich die Benutzer der lib dazu bringen, eine Marker-Schnittstelle zu implementieren, damit dieser Code funktioniert. – Abe

+0

Also würde ich mit einer TypeAdapterFactory gehen. Der Hauptpunkt ist, dass JSon die zu instantiierende Klasse bereitstellen muss. Gson ist nicht magisch, kann es nicht erraten für Sie :) – PomPom

+0

Seit 1.7 'GsonBuilder' Bauer hat [registerTypeHierarchyAdapter] (https://google.github.io/gson/apidocs/com/google/gson/GsonBuilder.html# registerTypeHierarchyAdapter-java.lang.Class-java.lang.Objekt-) Methode, die in diesem Fall besser geeignet ist. Siehe [Diskussion] (https://groups.google.com/forum/#!topic/google-gson/0ebOxifqwb0). – Vadzim

5

Angenommen, Sie diese 2 möglich JSON Antworten hat:

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... 
} 

Dann können Sie analysieren jede der möglichen JSON Antworten mit:

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

Sie eine Klassenstruktur wie folgt erstellen

Gson ignoriert alle JSON-Felder, die keinem der Attribute in entsprechen Ihre Klassenstruktur, so dass Sie eine einzelne Klasse unterschiedliche Antworten analysieren, anpassen können ...

Dann können Sie classA, welche der Attribute überprüfen, classB, ... nicht null ist, und Sie werden wissen, welche Antwort Sie erhalten haben .

+0

für eine Bibliothek Dies ist, den Benutzer veröffentlicht wird -> https://github.com/menacher/java-game-server so dass ich wirklich ihre Klassen kennen würde nicht. Also keine Möglichkeit, in die Response-Klasse zu füllen. – Abe

+1

@Abe, so dass Sie eine Reihe von JSON Antworten zu analysieren, und Sie wissen nicht, wie sie überhaupt aussehen? Das ist wirklich harte Arbeit! – MikO

+0

Eigentlich kann der Client den Klassennamen senden, da sie wissen, was sie senden, also ist es kein verlorener Grund. – Abe

1

Modellklasse erstellen,

public class MyModel { 

    private String errorId; 

    public String getErrorId() { 
     return errorId; 
    } 

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

erstellen Unterklasse

public class SubClass extends MyModel { 
     private String subString; 

     public String getSubString() { 
      return subString; 
     } 

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

Aufruf parseGson Methode

parseGson(subClass); 

Gson Parse-Methode mit Objektklasse

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

können Sie globale Variablen, die

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

Ungewiss MyModel werfen, wenn dies ist, was Sie fragen, wurden , aber indem ich die RuntimeTypeAdapterFactory-Klasse änderte, habe ich ein System für Unterklassen basierend auf Bedingungen in der Json-Quelle erstellt. 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); 

} 

Beispiel (aus einem Projekt genommen arbeite ich zur Zeit auf):

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

Verbrauch:

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

Die Hierachie Basisklasse Artikel. Währung, Ausrüstung, Edelstein und Karte erweitern dies.

+0

Das ist fast das, was ich will, aber meine Grundanforderung war, nicht verwandte Klassen zu identifizieren, was meiner Meinung nach nicht möglich ist. – Abe