在拉取数据时，有时候会遇到一些错误数据导致整张表都无法正常存储的情况，比如这种错误：
com.google.gson.JsonSyntaxException: java.lang.NumberFormatException: Invalid long: "null"
原json数据是这样的：
{
"id": "1202075683237523457",
"device_type": "00001001",
"device_id": "000d6f000a7ef40d",
"mode_id": "null",
"cmd_id": "color",
"cmd_order": null,
"cmd_papam": "{\"p1\":\"175\",\"p2\":\"240\",\"p3\":\"188\",\"p4\":\"\"}"
}
但需要序列化的mode_id本应该是一个long型，但由于某种原因，服务端提供的数据中出现了"null"这种无法正常转换为long的数据，那么gson在反序列化json数据的时候，就会出现异常。
这个时候，最好的方法自然是要求服务端校验数据…
当然在无奈的情况下，只能强行解析这样子。
用法
这个时候就需要用到gson的一些特殊用法：
public GsonBuilder registerTypeAdapter(Type type, Object typeAdapter)
顾名思义，用以注册TypeAdapter的方法，TypeAdapter是gson的核心模块之一，用于转换与解析数据，不可或缺。
在通常情况下，仅需要一行代码就能将json数据转换为想要的Model类型，比如想让将上面的json数据反序列化为一个ModeCmd实例：
Gson gson = new Gson();
ModeCmd modeCmd = gson.fromJson(json,new TypeToken<ModeCmd>(){
}.getType());
这种情况下，其实是使用的gson默认配置的TypeAdapter，遇到错误数据的时候，会按正常逻辑抛出异常，这个时候可以写一个JsonDeserializer通过registerTypeAdapter配置一个TypeAdapter，使其在解析ModeCmd数据时，使用JsonDeserializer来解析。
JsonDeserializer可以写成这样：
private JsonDeserializer<ModeCmd> modeCmdJsonDeserializer = new JsonDeserializer<ModeCmd>() {
@Override
public ModeCmd deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
try {
json.getAsJsonObject().get("mode_id").getAsLong();
} catch (Exception ex) {
ex.printStackTrace();
json.getAsJsonObject().addProperty("mode_id", "0");
}
return gson.getGson().fromJson(json, typeOfT);
}
};
这里是将mode_id的数据强行换为“0”，也可以做其他处理。
最后使用
Gson gson = new GsonBuilder().registerTypeAdapter(ModeCmd.class, modeCmdJsonDeserializer).create();
ModeCmd modeCmd = gson.fromJson(json,new TypeToken<ModeCmd>(){
}.getType())
得到的gson去解析数据即可。
原理
之所以可以这么做的缘由，是因为gson解析数据也是遍历JsonTree一层一层选择合适TypeAdapter去解析当前层数据的，并且gson在新建时（构造方法）已经内置了大量TypeAdapter：
//Gson
List<TypeAdapterFactory> factories = new ArrayList<TypeAdapterFactory>();
// built-in type adapters that cannot be overridden
factories.add(TypeAdapters.JSON_ELEMENT_FACTORY);
factories.add(ObjectTypeAdapter.FACTORY);
// the excluder must precede all adapters that handle user-defined types
factories.add(excluder);
// user's type adapters
factories.addAll(typeAdapterFactories);
// type adapters for basic platform types
factories.add(TypeAdapters.STRING_FACTORY);
factories.add(TypeAdapters.INTEGER_FACTORY);
factories.add(TypeAdapters.BOOLEAN_FACTORY);
factories.add(TypeAdapters.BYTE_FACTORY);
factories.add(TypeAdapters.SHORT_FACTORY);
TypeAdapter<Number> longAdapter = longAdapter(longSerializationPolicy);
factories.add(TypeAdapters.newFactory(long.class, Long.class, longAdapter));
factories.add(TypeAdapters.newFactory(double.class, Double.class,
doubleAdapter(serializeSpecialFloatingPointValues)));
factories.add(TypeAdapters.newFactory(float.class, Float.class,
floatAdapter(serializeSpecialFloatingPointValues)));
factories.add(TypeAdapters.NUMBER_FACTORY);
factories.add(TypeAdapters.ATOMIC_INTEGER_FACTORY);
factories.add(TypeAdapters.ATOMIC_BOOLEAN_FACTORY);
factories.add(TypeAdapters.newFactory(AtomicLong.class, atomicLongAdapter(longAdapter)));
factories.add(TypeAdapters.newFactory(AtomicLongArray.class, atomicLongArrayAdapter(longAdapter)));
factories.add(TypeAdapters.ATOMIC_INTEGER_ARRAY_FACTORY);
factories.add(TypeAdapters.CHARACTER_FACTORY);
factories.add(TypeAdapters.STRING_BUILDER_FACTORY);
factories.add(TypeAdapters.STRING_BUFFER_FACTORY);
factories.add(TypeAdapters.newFactory(BigDecimal.class, TypeAdapters.BIG_DECIMAL));
factories.add(TypeAdapters.newFactory(BigInteger.class, TypeAdapters.BIG_INTEGER));
factories.add(TypeAdapters.URL_FACTORY);
factories.add(TypeAdapters.URI_FACTORY);
factories.add(TypeAdapters.UUID_FACTORY);
factories.add(TypeAdapters.CURRENCY_FACTORY);
factories.add(TypeAdapters.LOCALE_FACTORY);
factories.add(TypeAdapters.INET_ADDRESS_FACTORY);
factories.add(TypeAdapters.BIT_SET_FACTORY);
factories.add(DateTypeAdapter.FACTORY);
factories.add(TypeAdapters.CALENDAR_FACTORY);
factories.add(TimeTypeAdapter.FACTORY);
factories.add(SqlDateTypeAdapter.FACTORY);
factories.add(TypeAdapters.TIMESTAMP_FACTORY);
factories.add(ArrayTypeAdapter.FACTORY);
factories.add(TypeAdapters.CLASS_FACTORY);
// type adapters for composite and user-defined types
factories.add(new CollectionTypeAdapterFactory(constructorConstructor));
factories.add(new MapTypeAdapterFactory(constructorConstructor, complexMapKeySerialization));
this.jsonAdapterFactory = new JsonAdapterAnnotationTypeAdapterFactory(constructorConstructor);
factories.add(jsonAdapterFactory);
factories.add(TypeAdapters.ENUM_FACTORY);
factories.add(new ReflectiveTypeAdapterFactory(
constructorConstructor, fieldNamingStrategy, excluder, jsonAdapterFactory));
this.factories = Collections.unmodifiableList(factories);
包括了JsonElement/Integer/Long各种基础类型相关的TypeAdapter，比如解析字符串使用的是STRING_FACTORY ：
public static final TypeAdapterFactory STRING_FACTORY = newFactory(String.class, STRING);
public static final TypeAdapter<StringBuilder> STRING_BUILDER = new TypeAdapter<StringBuilder>() {
@Override
public StringBuilder read(JsonReader in) throws IOException {
if (in.peek() == JsonToken.NULL) {
in.nextNull();
return null;
}
return new StringBuilder(in.nextString());
}
@Override
public void write(JsonWriter out, StringBuilder value) throws IOException {
out.value(value == null ? null : value.toString());
}
};
而当我们使用gson.fromJson方法时，就会在factories中挑选合适的TypeAdapter去解析数据：
//Gson.java
public <T> T fromJson(JsonElement json, Type typeOfT) throws JsonSyntaxException {
if (json == null) {
return null;
}
return (T) fromJson(new JsonTreeReader(json), typeOfT);
}
public <T> T fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxException {
//略
TypeToken<T> typeToken = (TypeToken<T>) TypeToken.get(typeOfT);
TypeAdapter<T> typeAdapter = getAdapter(typeToken);
T object = typeAdapter.read(reader);
return object;
//略
}
public <T> TypeAdapter<T> getAdapter(TypeToken<T> type) {
//略
try {
FutureTypeAdapter<T> call = new FutureTypeAdapter<T>();
threadCalls.put(type, call);
for (TypeAdapterFactory factory : factories) {
TypeAdapter<T> candidate = factory.create(this, type);
if (candidate != null) {
call.setDelegate(candidate);
typeTokenCache.put(type, candidate);
return candidate;//取得合适的TypeAdapter
}
}
throw new IllegalArgumentException("GSON cannot handle " + type);
} finally {
//略
}
}
可以在getAdapter方法看到，当json数据传入时会遍历factories并去取得对应的TypeAdapter，而后去解析。
所以当我们使用registerTypeAdapter方法时，其实就是手动添加了一个TypeAdapter以供选择：
//GsonBuilder.java
public GsonBuilder registerTypeAdapter(Type type, Object typeAdapter) {
$Gson$Preconditions.checkArgument(typeAdapter instanceof JsonSerializer<?>
|| typeAdapter instanceof JsonDeserializer<?>
|| typeAdapter instanceof InstanceCreator<?>
|| typeAdapter instanceof TypeAdapter<?>);
if (typeAdapter instanceof InstanceCreator<?>) {
instanceCreators.put(type, (InstanceCreator) typeAdapter);
}
if (typeAdapter instanceof JsonSerializer<?> || typeAdapter instanceof JsonDeserializer<?>) {
TypeToken<?> typeToken = TypeToken.get(type);
factories.add(TreeTypeAdapter.newFactoryWithMatchRawType(typeToken, typeAdapter));
}
if (typeAdapter instanceof TypeAdapter<?>) {
factories.add(TypeAdapters.newFactory(TypeToken.get(type), (TypeAdapter)typeAdapter));
}
return this;
}
最终解析的时候，会走到调用deserialize的地方，也是JsonDeserializer之所以生效的源头：
//TreeTypeAdapter.java
@Override public T read(JsonReader in) throws IOException {
if (deserializer == null) {
return delegate().read(in);
}
JsonElement value = Streams.parse(in);
if (value.isJsonNull()) {
return null;
}
return deserializer.deserialize(value, typeToken.getType(), context);
}
以上。