Gson源码解析

最新推荐文章于 2024-02-02 14:57:36 发布
最新推荐文章于 2024-02-02 14:57:36 发布
阅读量292 收藏
点赞数 1
分类专栏： android java 文章标签： Gson Android Java Json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/XG1057415595/article/details/113833982
版权

Gson 混淆 Json转对象 TypeAdapter @SerializedName
关键词由CSDN通过智能技术生成

这里写自定义目录标题

遇到的问题

在使用Gson将 Json字符创 转化为 Java 对象的时候，由于没有给字段加上@Serializable 注解，导致在混淆前运行正常，混淆后运行错误，所以跟了一下源码，就有了这篇文章。

Gson

版本

2.8.5

Json 转 对象

将Json字符串转化为数据类实例，可以调用 Gson.fromJson() ，所以我们从 fromJson() 方法这个入口开始。

进入 fromJson() 方法后，内部又调用了多个重载方法()

public <T> T fromJson(String json, Class<T> classOfT) throws JsonSyntaxException {
	// 调用 fromJson 重载方法
    Object object = fromJson(json, (Type) classOfT);
    return Primitives.wrap(classOfT).cast(object);
  }
public <T> T fromJson(String json, Type typeOfT) throws JsonSyntaxException {
    if (json == null) {
      return null;
    }
    StringReader reader = new StringReader(json);
    T target = (T) fromJson(reader, typeOfT);
    return target;
  }
public <T> T fromJson(Reader json, Type typeOfT) throws JsonIOException, JsonSyntaxException {
    JsonReader jsonReader = newJsonReader(json);
    T object = (T) fromJson(jsonReader, typeOfT);
    assertFullConsumption(object, jsonReader);
    return object;
  }
public <T> T fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxException {
    boolean isEmpty = true;
    boolean oldLenient = reader.isLenient();
    reader.setLenient(true);
    try {
      // 如果 json字符串长度为0，则 peek方法会抛出 EOFException异常
      reader.peek();
      isEmpty = false;
      // 将 Type 作为参数，创建一个 TypeToken 对象
      TypeToken<T> typeToken = (TypeToken<T>) TypeToken.get(typeOfT);
      // 通过 TypeToken 创建一个 TypeAdapter
      TypeAdapter<T> typeAdapter = getAdapter(typeToken);
      T object = typeAdapter.read(reader);
      return object;
    } catch (EOFException e) {
      /*
       * For compatibility with JSON 1.5 and earlier, we return null for empty
       * documents instead of throwing.
       */
      if (isEmpty) {
        return null;
      }
      throw new JsonSyntaxException(e);
    } catch (IllegalStateException e) {
      throw new JsonSyntaxException(e);
    } catch (IOException e) {
      // TODO(inder): Figure out whether it is indeed right to rethrow this as JsonSyntaxException
      throw new JsonSyntaxException(e);
    } finally {
      reader.setLenient(oldLenient);
    }
  }

最终是到最后一个方法 fromJson(JsonReader reader, Type typeOfT) 来得到 Java 对象的，这个方法里有个比较关键的地方其实就两步，第一步是调用 getAdapter() 获取 TypeAdapter，第二部是调用该 TypeAdapter 的 read() 方法得到我们想要的 数据类实例。

我们先看一下第一步 getAdapter() 方法：

public <T> TypeAdapter<T> getAdapter(TypeToken<T> type) {
	// 先从缓存中获取 TypeAdapter
    TypeAdapter<?> cached = typeTokenCache.get(type == null ? NULL_KEY_SURROGATE : type);
    if (cached != null) {
      return (TypeAdapter<T>) cached;
    }

    //......

    try {
      FutureTypeAdapter<T> call = new FutureTypeAdapter<T>();
      threadCalls.put(type, call);

      for (TypeAdapterFactory factory : factories) {
        // 遍历 factories 创建 TypeAdapter
        TypeAdapter<T> candidate = factory.create(this, type);
        if (candidate != null) {
          // 如果 candidate 不为空，说明创建成功
          // 用 FutureTypeAdapter 包装 TypeAdapter
          call.setDelegate(candidate);
          // 将该 TypeAdapter 存入缓存
          typeTokenCache.put(type, candidate);
          return candidate;
        }
      }
      throw new IllegalArgumentException("GSON cannot handle " + type);
    } finally {
      threadCalls.remove(type);

      if (requiresThreadLocalCleanup) {
        calls.remove();
      }
    }
  }

我们可以看到 TypeAdapter 是通过 工厂方法创建的，这里的 factories 就是个创建 TypeAdapter 的工厂集合，这里举例几个工厂：
① Object 类型：当数据类型 是 Object 时，使用此工厂创建 TypeAdapter

public final class ObjectTypeAdapter extends TypeAdapter<Object> {
  public static final TypeAdapterFactory FACTORY = new TypeAdapterFactory() {
    @SuppressWarnings("unchecked")
    @Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
      if (type.getRawType() == Object.class) {
        return (TypeAdapter<T>) new ObjectTypeAdapter(gson);
      }
      return null;
    }
  };
}

②基本数据类型及其包装类型：

public static <TT> TypeAdapterFactory newFactory(
    final Class<TT> unboxed, final Class<TT> boxed, final TypeAdapter<? super TT> typeAdapter) {
  return new TypeAdapterFactory() {
    @SuppressWarnings("unchecked") // we use a runtime check to make sure the 'T's equal
    @Override public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
      Class<? super T> rawType = typeToken.getRawType();
      return (rawType == unboxed || rawType == boxed) ? (TypeAdapter<T>) typeAdapter : null;
    }
    @Override public String toString() {
      return "Factory[type=" + boxed.getName()
          + "+" + unboxed.getName() + ",adapter=" + typeAdapter + "]";
    }
  };
}

③Object 类型的子类

public final class ReflectiveTypeAdapterFactory implements TypeAdapterFactory {
    @Override public <T> TypeAdapter<T> create(Gson gson, final TypeToken<T> type) {
      Class<? super T> raw = type.getRawType();

      if (!Object.class.isAssignableFrom(raw)) {
        return null; // it's a primitive!
      }
      // 获得一个 ObjectConstructor
      ObjectConstructor<T> constructor = constructorConstructor.get(type);
      // 调用 getBoundFields 得到 BoundField map集合
      // 用 constructor 和 BoundField 创建 Adapter(内部类)
      return new Adapter<T>(constructor, getBoundFields(gson, type, raw));
    }
    
    public static final class Adapter<T> extends TypeAdapter<T> {
    private final ObjectConstructor<T> constructor;
    private final Map<String, BoundField> boundFields;

    Adapter(ObjectConstructor<T> constructor, Map<String, BoundField> boundFields) {
      this.constructor = constructor;
      this.boundFields = boundFields;
    }

    @Override public T read(JsonReader in) throws IOException {
      if (in.peek() == JsonToken.NULL) {
        in.nextNull();
        return null;
      }

      T instance = constructor.construct();

      try {
        in.beginObject();
        while (in.hasNext()) {
          String name = in.nextName();
          BoundField field = boundFields.get(name);
          if (field == null || !field.deserialized) {
            in.skipValue();
          } else {
            field.read(in, instance);
          }
        }
      } catch (IllegalStateException e) {
        throw new JsonSyntaxException(e);
      } catch (IllegalAccessException e) {
        throw new AssertionError(e);
      }
      in.endObject();
      return instance;
    }

    @Override public void write(JsonWriter out, T value) throws IOException {
      if (value == null) {
        out.nullValue();
        return;
      }

      out.beginObject();
      try {
        for (BoundField boundField : boundFields.values()) {
          if (boundField.writeField(value)) {
            out.name(boundField.name);
            boundField.write(out, value);
          }
        }
      } catch (IllegalAccessException e) {
        throw new AssertionError(e);
      }
      out.endObject();
    }
  }
  }

一般情况下，我们自己编写的数据类，使用的是第三种工厂创建得到 TypeAdapter。
这个工厂有一个create() 方法，create() 中先通过 constructorConstructor.get() 得到一个 ObjectConstructor 构建器对象，很明显这个 ObjectConstructor 构建器就是用来创建数据类实例的。这里最终会通过 newDefaultConstructor() 得到一个默认的构建器，该构建器的作用就是使用反射调用类的无参构造函数来得到数据类实例。

得到 ObjectConstructor 后，紧接着调用 getBoundFields 得到 BoundField map集合， 用 ObjectConstructor 和 BoundField 创建 Adapter(该 Adapter 是 ReflectiveTypeAdapterFactory 的内部类)
我们先看一下 newDefaultConstructor() 得到的默认构建器

private <T> ObjectConstructor<T> newDefaultConstructor(Class<? super T> rawType) {
  try {
    final Constructor<? super T> constructor = rawType.getDeclaredConstructor();
    if (!constructor.isAccessible()) {
      accessor.makeAccessible(constructor);
    }
    return new ObjectConstructor<T>() {
      @SuppressWarnings("unchecked") // T is the same raw type as is requested
      @Override public T construct() {
        try {
          Object[] args = null;
          //使用反射调用无参构造函数来得到数据类实例
          return (T) constructor.newInstance(args);
        } catch (InstantiationException e) {
          // TODO: JsonParseException ?
          throw new RuntimeException("Failed to invoke " + constructor + " with no args", e);
        } catch (InvocationTargetException e) {
          // TODO: don't wrap if cause is unchecked!
          // TODO: JsonParseException ?
          throw new RuntimeException("Failed to invoke " + constructor + " with no args",
              e.getTargetException());
        } catch (IllegalAccessException e) {
          throw new AssertionError(e);
        }
      }
    };
  } catch (NoSuchMethodException e) {
    return null;
  }
}

得到 ObjectConstructor 后，我们看 getBoundFields() 方法

private Map<String, BoundField> getBoundFields(Gson context, TypeToken<?> type, Class<?> raw) {
  Map<String, BoundField> result = new LinkedHashMap<String, BoundField>();
  if (raw.isInterface()) {
    return result;
  }

  Type declaredType = type.getType();
  while (raw != Object.class) {
      // 获取数据类型的所有字段
    Field[] fields = raw.getDeclaredFields();
    for (Field field : fields) {
      boolean serialize = excludeField(field, true);
      boolean deserialize = excludeField(field, false);
      if (!serialize && !deserialize) {
        continue;
      }
      accessor.makeAccessible(field);
      // 获取字段的 Type 类型
      Type fieldType = $Gson$Types.resolve(type.getType(), raw, field.getGenericType());
      List<String> fieldNames = getFieldNames(field);
      BoundField previous = null;
      for (int i = 0, size = fieldNames.size(); i < size; ++i) {
        // 获取字段名
        String name = fieldNames.get(i);
        if (i != 0) serialize = false; // only serialize the default name
        // 创建字段的 BoundField 对象
        BoundField boundField = createBoundField(context, field, name,
            TypeToken.get(fieldType), serialize, deserialize);
        BoundField replaced = result.put(name, boundField);
        if (previous == null) previous = replaced;
      }
      if (previous != null) {
        throw new IllegalArgumentException(declaredType
            + " declares multiple JSON fields named " + previous.name);
      }
    }
    type = TypeToken.get($Gson$Types.resolve(type.getType(), raw, raw.getGenericSuperclass()));
    raw = type.getRawType();
  }
  return result;
}

getBoundFields() 方法的作用就是，反射获取数据类的所有字段，并获取字段名称，然后为每个字段创建BoundField。
我们先看看获取字段名称的方法 getFieldNames()

private List<String> getFieldNames(Field f) {
  SerializedName annotation = f.getAnnotation(SerializedName.class);
  if (annotation == null) {
    // 如果字段没有加 SerializedName 注解，则直接获取字段名称
    String name = fieldNamingPolicy.translateName(f);
    return Collections.singletonList(name);
  }
  // 如果字段加了 SerializedName 注解，则获取该注解的 value
  String serializedName = annotation.value();
  String[] alternates = annotation.alternate();
  if (alternates.length == 0) {
    return Collections.singletonList(serializedName);
  }

  List<String> fieldNames = new ArrayList<String>(alternates.length + 1);
  fieldNames.add(serializedName);
  for (String alternate : alternates) {
    fieldNames.add(alternate);
  }
  return fieldNames;
}

很重要的一点，如果字段加了 @Serializable 注解，则会获取该注解的 value值，如果没有加 @Serializable 注解， 则直接获取字段名。
然后我们再看看创建 BoundField 的方法：

private ReflectiveTypeAdapterFactory.BoundField createBoundField(
    final Gson context, final Field field, final String name,
    final TypeToken<?> fieldType, boolean serialize, boolean deserialize) {
  final boolean isPrimitive = Primitives.isPrimitive(fieldType.getRawType());
  // special casing primitives here saves ~5% on Android...
  JsonAdapter annotation = field.getAnnotation(JsonAdapter.class);
  TypeAdapter<?> mapped = null;
  if (annotation != null) {
    mapped = jsonAdapterFactory.getTypeAdapter(
        constructorConstructor, context, fieldType, annotation);
  }
  final boolean jsonAdapterPresent = mapped != null;
  if (mapped == null) mapped = context.getAdapter(fieldType);

  final TypeAdapter<?> typeAdapter = mapped;
  return new ReflectiveTypeAdapterFactory.BoundField(name, serialize, deserialize) {
    @SuppressWarnings({"unchecked", "rawtypes"}) // the type adapter and field type always agree
    @Override void write(JsonWriter writer, Object value)
        throws IOException, IllegalAccessException {
      Object fieldValue = field.get(value);
      TypeAdapter t = jsonAdapterPresent ? typeAdapter
          : new TypeAdapterRuntimeTypeWrapper(context, typeAdapter, fieldType.getType());
      t.write(writer, fieldValue);
    }
    @Override void read(JsonReader reader, Object value)
        throws IOException, IllegalAccessException {
      Object fieldValue = typeAdapter.read(reader);
      if (fieldValue != null || !isPrimitive) {
        field.set(value, fieldValue);
      }
    }
    @Override public boolean writeField(Object value) throws IOException, IllegalAccessException {
      if (!serialized) return false;
      Object fieldValue = field.get(value);
      return fieldValue != value; // avoid recursion for example for Throwable.cause
    }
  };
}

可见，BoundField 的作用就是对指定字段进行读写。
这个时候，我们就通过 ObjectConstructor 和 BoundField 创建得到了 TypeAdapter。

public static final class Adapter<T> extends TypeAdapter<T> {
  private final ObjectConstructor<T> constructor;
  private final Map<String, BoundField> boundFields;

  Adapter(ObjectConstructor<T> constructor, Map<String, BoundField> boundFields) {
    this.constructor = constructor;
    this.boundFields = boundFields;
  }

  @Override public T read(JsonReader in) throws IOException {
    if (in.peek() == JsonToken.NULL) {
      in.nextNull();
      return null;
    }
    // 通过上面创建的 ObjectConstructor 创建一个数据类对象
    T instance = constructor.construct();

    try {
      in.beginObject();
      // 将 json 的值写入到对象中
      while (in.hasNext()) {
        String name = in.nextName(); // 获取 json 的键
        BoundField field = boundFields.get(name); // 通过 name 获取对象的 boundField
        if (field == null || !field.deserialized) {
          in.skipValue();
        } else {
          // 调用 boundField 的 read 方法
          field.read(in, instance);
        }
      }
    } catch (IllegalStateException e) {
      throw new JsonSyntaxException(e);
    } catch (IllegalAccessException e) {
      throw new AssertionError(e);
    }
    in.endObject();
    return instance;
  }

  @Override public void write(JsonWriter out, T value) throws IOException {
    if (value == null) {
      out.nullValue();
      return;
    }

    out.beginObject();
    try {
      for (BoundField boundField : boundFields.values()) {
        if (boundField.writeField(value)) {
          out.name(boundField.name);
          boundField.write(out, value);
        }
      }
    } catch (IllegalAccessException e) {
      throw new AssertionError(e);
    }
    out.endObject();
  }
}

fromJson 得到 TypeAdapter 后，会调用 TypeAdapter 的 read() 方法，得到一个 数据类实例。
read() 方法上面已经给出了，就是先用 ObjectConstructor 创建数据类实例，然后通过每个字段的BoundField 的 read() 方法写入字段的值。

总结

开头的问题已经得到答案了，如果字段加了 @Serializable 注解，则会获取该注解的 value值作为映射的 key，如果没有加 @Serializable 注解， 则直接获取字段名作为映射的 key。而如果没有加注解，混淆后的字段名就是 abcd，导致混淆后无法得到正确结果。

_SkUnK
关注
专栏目录
Gson 源码解析
5a59
06-27 748
Gson使用方法： Gson.fromJson(String json, Class clazz) 所以从 fromJson 开始解析Gson.javafromJson() 有多个重载函数，最终都会调用下面这个 public <T> T fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxExc
google专用解析json工具之gson源码
11-16
Gson源码提供了深入理解其工作原理的机会，这对于开发者来说是一个宝贵的学习资源，特别是对于那些希望自定义序列化和反序列化过程或者优化JSON处理的开发者。 1. **Gson的核心概念** - **JsonReader与JsonWriter*...
gson源码.rar
09-14
谷歌gson源代码，对gson 框架有兴趣的人可以看下，经本人亲测完全好使 大多数开源库并没有对泛型提供完全的支持。于是,Gson在这两个重要的设计目标下诞生了
Gson 源码分析 总结
SunnyAndroider专栏
10-28 2931
1   Gson 的简单使用： 简单对象的序列化和反序列化： Gson gson = new Gson(); // Or use new GsonBuilder().create();MyType target = new MyType();String json = gson.toJson(target); // serializes target to JsonMyType t
GSON源码解析
王胖胖儿的博客
02-22 352
Gson源码解析 Gson的解析原理大致分为如下两种情况。 1.如果是通过GsonBuilder创建的Gson对象，那么就用自定义的TyperAdapter来完成json的解析 2.如果是通过new Gson()创建的Gson对象，那么就用Java反射机制来完成json的解析。 那么Gson在是怎么判断是上述两种方式的哪一种呢？我们查看源码时，并没有提供一个特殊的字段来辨别？ Gson(final...
子墨庖丁-Gson的源码分析(1)-开篇
<非子墨>的空间
02-13 5107
Gson源码分析开篇
Gson源码分析
dsfllx的博客
03-17 329
楔子 目前项目中使用的json序列号依赖都是fastjson，但是由于fastjson漏洞频发，决定一律切换为Google的Gson。本以为不过是序列化反序列化而已，两个接口搞定，但是却出现了含有泛型的对象在反序列化时，int被转为double的情况（详情和解决方案可以参考博客Gson格式转换Integer变为Double类型问题解决），为了防止再发生类似的情况，对Gson的源码进行了一点简单的分析。 序列化介绍 在分析源码之前，先总结一些序列化的知识。serialization是将一个对象转为byte s
JAVA使用Gson解析json数据实例解析
10-22
JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，易于阅读和编写，同时也易于机器解析和生成。接下来通过本文给大家介绍JAVA使用Gson解析json数据实例解析，需要的朋友参考下吧
gson包解析json 数据
05-04
Gson是Google开发的一款强大的Java库，用于在Java对象和JSON数据之间进行映射。它使得Java对象可以轻松地转换成JSON格式，反之亦然。...如果你对JSON处理有深入需求，理解并掌握Gson的源码将是一个有价值的学习经历。
【Gson】源码解析
LFSenior
10-08 546
private FieldNamingStrategy fieldNamingPolicy = FieldNamingPolicy.IDENTITY; public Gson create() { List&lt;TypeAdapterFactory&gt; factories = new ArrayList&lt;TypeAdapterFactory&gt;(); factories...
GSON源码完整版
03-23
gson完整源码gson完整源码gson完整源码
gson最新源码
04-17
gson最新源码,从google网站搬来的
Gson实例源码下载
12-10
之前在Volley框架JsonObjectRequest和JsonArrayRequest的使用中搭配了Gson库，操作JSON数据格式非常方便，所以这里详细阐述下Gson的使用方法。
Gson源码解读
最新发布
qq_40900926的博客
02-02 1291
gson作为流行的json工具，笔者使用较多。本文主要目的是解读下Gson的源码实现，就没有然后了。
Gson 源码分析
taylor的专栏
10-02 5186
最近研究了google开源的Json库Gson，在这里进行总结一下，应该会分为3篇博客。第一篇主要讲一下Gson的整个框架吧；第二篇主要总结一下Gson关于反射的部分;最后一篇会总结一下JsonWriter和JsonReader，主要是Json对象的处理啦。Gson Gson是可以转换Java对象为JSON表示的java库，也可以将JSON转换为Java对象，并且可以转换你没有源代码的预设的复杂对象
Gson源码解析（一）
qq_38817183的博客
06-25 391
Gson源码解析（一）Gson序列化流程 我们从fromJson开始。 public <T> T fromJson(String json, Class<T> classOfT) throws JsonSyntaxException { Object object = fromJson(json, (Type) classOfT); return Primitives.wrap(classOfT).cast(object); } 经过几个fromJson重载方法后，会将我们
Gson源码分析开篇
helloworld
05-04 285
如何解析json json本质上讲是一个结构型的文本。可以对其也解析的复杂程度远不如编译器。编译器的一个基础功能便是词法分析。而Gson的核心功能之一，也是词法分析。 词法分析的任务是要解析出Token流，Token是一个二元组。类似于这样，Token<符号，种别码>。 Gson中与token有关的结构有两个，分别是JsonToken和JsonScope： ··· public enu...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值