这需要一个特殊的后处理类型适配器，它可以进行反序列化和收集未知属性。
我会这样做类似于以下内容。
下面的接口是一个真实对象和类型适配器之间的桥梁。
这里没什么特别的。
interface IUnknownPropertiesConsumer {
void acceptUnknownProperties(JsonObject jsonObject);
}
现在，您可以拥有实现上述接口的以下映射。
final class MyClass
implements IUnknownPropertiesConsumer {
final String sub = null;
final String iss = null;
transient JsonObject customProperties;
@Override
public void acceptUnknownProperties(final JsonObject customProperties) {
this.customProperties = customProperties;
}
}
请注意，如果您由于某种原因无法更改映射，您仍然可以调整以下类型适配器来解决问题：
final class UnknownPropertiesTypeAdapterFactory
implements TypeAdapterFactory {
private static final TypeAdapterFactory instance = new UnknownPropertiesTypeAdapterFactory();
private UnknownPropertiesTypeAdapterFactory() {
}
static TypeAdapterFactory get() {
return instance;
}
@Override
public <T> TypeAdapter<T> create(final Gson gson, final TypeToken<T> typeToken) {
// Check if we can deal with the given type
if ( !IUnknownPropertiesConsumer.class.isAssignableFrom(typeToken.getRawType()) ) {
return null;
}
// If we can, we should get the backing class to fetch its fields from
@SuppressWarnings("unchecked")
final Class<IUnknownPropertiesConsumer> rawType = (Class<IUnknownPropertiesConsumer>) typeToken.getRawType();
@SuppressWarnings("unchecked")
final TypeAdapter<IUnknownPropertiesConsumer> delegateTypeAdapter = (TypeAdapter<IUnknownPropertiesConsumer>) gson.getDelegateAdapter(this, typeToken);
// Excluder is necessary to check if the field can be processed
// Basically it's not required, but it makes the check more complete
final Excluder excluder = gson.excluder();
// This is crucial to map fields and JSON object properties since Gson supports name remapping
final FieldNamingStrategy fieldNamingStrategy = gson.fieldNamingStrategy();
final TypeAdapter<IUnknownPropertiesConsumer> unknownPropertiesTypeAdapter = UnknownPropertiesTypeAdapter.create(rawType, delegateTypeAdapter, excluder, fieldNamingStrategy);
@SuppressWarnings("unchecked")
final TypeAdapter<T> castTypeAdapter = (TypeAdapter<T>) unknownPropertiesTypeAdapter;
return castTypeAdapter;
}
private static final class UnknownPropertiesTypeAdapter<T extends IUnknownPropertiesConsumer>
extends TypeAdapter<T> {
private final TypeAdapter<T> typeAdapter;
private final Collection<String> propertyNames;
private UnknownPropertiesTypeAdapter(final TypeAdapter<T> typeAdapter, final Collection<String> propertyNames) {
this.typeAdapter = typeAdapter;
this.propertyNames = propertyNames;
}
private static <T extends IUnknownPropertiesConsumer> TypeAdapter<T> create(final Class<? super T> clazz, final TypeAdapter<T> typeAdapter,
final Excluder excluder, final FieldNamingStrategy fieldNamingStrategy) {
final Collection<String> propertyNames = getPropertyNames(clazz, excluder, fieldNamingStrategy);
return new UnknownPropertiesTypeAdapter<>(typeAdapter, propertyNames);
}
@Override
public void write(final JsonWriter out, final T value)
throws IOException {
typeAdapter.write(out, value);
}
@Override
public T read(final JsonReader in) {
// JsonParser holds no state so instantiation is a bit excessive, but Gson may change in the future
final JsonParser jsonParser = new JsonParser();
// In its simplest solution, we can just collect a JSON tree because its much easier to process
final JsonObject jsonObjectToParse = jsonParser.parse(in).getAsJsonObject();
final JsonObject unknownProperties = new JsonObject();
for ( final Map.Entry<String, JsonElement> e : jsonObjectToParse.entrySet() ) {
final String propertyName = e.getKey();
// No in the object fields?
if ( !propertyNames.contains(propertyName) ) {
// Then we assume the property is unknown
unknownProperties.add(propertyName, e.getValue());
}
}
// First convert the above JSON tree to an object
final T object = typeAdapter.fromJsonTree(jsonObjectToParse);
// And do the post-processing
object.acceptUnknownProperties(unknownProperties);
return object;
}
private static Collection<String> getPropertyNames(final Class<?> clazz, final Excluder excluder, final FieldNamingStrategy fieldNamingStrategy) {
final Collection<String> propertyNames = new ArrayList<>();
// Class fields are declared per class so we have to traverse the whole hierarachy
for ( Class<?> i = clazz; i.getSuperclass() != null && i != Object.class; i = i.getSuperclass() ) {
for ( final Field declaredField : i.getDeclaredFields() ) {
// If the class field is not excluded
if ( !excluder.excludeField(declaredField, false) ) {
// We can translate the field name to its property name counter-part
final String propertyName = fieldNamingStrategy.translateName(declaredField);
propertyNames.add(propertyName);
}
}
}
return propertyNames;
}
}
}
现在一次性全部使用：
private static final Gson gson = new GsonBuilder()
.registerTypeAdapterFactory(UnknownPropertiesTypeAdapterFactory.get())
.create();
...
// Assuming jsonReader is a reader to read your original JSON
final MyClass o = gson.fromJson(jsonReader, MyClass.class);
System.out.println(o.sub);
System.out.println(o.iss);
System.out.println(o.customProperties);
那么输出如下：
value
value2
{"unknown_property":"value3","unknown_property_2":{"a":1,"b":2}}